home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / sound / fm.c < prev    next >
C/C++ Source or Header  |  2000-05-21  |  101KB  |  3,581 lines
  1. #define YM2610B_WARNING
  2.  
  3. /* YM2608 rhythm data is PCM ,not an ADPCM */
  4. #define YM2608_RHYTHM_PCM
  5.  
  6. /*
  7. **
  8. ** File: fm.c -- software implementation of FM sound generator
  9. **
  10. ** Copyright (C) 1998 Tatsuyuki Satoh , MultiArcadeMachineEmurator development
  11. **
  12. ** Version 0.37
  13. **
  14. */
  15.  
  16. /*
  17. **** change log. (hiro-shi) ****
  18. ** 08-12-98:
  19. ** rename ADPCMA -> ADPCMB, ADPCMB -> ADPCMA
  20. ** move ROM limit check.(CALC_CH? -> 2610Write1/2)
  21. ** test program (ADPCMB_TEST)
  22. ** move ADPCM A/B end check.
  23. ** ADPCMB repeat flag(no check)
  24. ** change ADPCM volume rate (8->16) (32->48).
  25. **
  26. ** 09-12-98:
  27. ** change ADPCM volume. (8->16, 48->64)
  28. ** replace ym2610 ch0/3 (YM-2610B)
  29. ** init cur_chip (restart bug fix)
  30. ** change ADPCM_SHIFT (10->8) missing bank change 0x4000-0xffff.
  31. ** add ADPCM_SHIFT_MASK
  32. ** change ADPCMA_DECODE_MIN/MAX.
  33. */
  34.  
  35. /*
  36.     no check:
  37.         YM2608 rhythm sound
  38.         OPN SSG type envelope (SEG)
  39.         YM2151 CSM speech mode
  40.  
  41.     no support:
  42.         status BUSY flag (everytime not busy)
  43.         YM2608 status mask (register :0x110)
  44.         YM2608 RYTHM sound
  45.         YM2608 PCM memory data access , DELTA-T-ADPCM with PCM port
  46.         YM2151 CSM speech mode with internal timer
  47.  
  48.     preliminary :
  49.         key scale level rate (?)
  50.         attack rate time rate , curve
  51.         decay  rate time rate , curve
  52.         self-feedback algorythm
  53.         YM2610 ADPCM-A mixing level , decode algorythm
  54.         YM2151 noise mode (CH7.OP4)
  55.         LFO contoller (YM2612/YM2610/YM2608/YM2151)
  56.  
  57.     note:
  58.                         OPN                           OPM
  59.         fnum          fM * 2^20 / (fM/(12*n))
  60.         TimerOverA    ( 12*n)*(1024-NA)/fM        64*(1024-Na)/fM
  61.         TimerOverB    (192*n)*(256-NB)/fM       1024*(256-Nb)/fM
  62.         output bits   10bit<<3bit               16bit * 2ch (YM3012=10bit<<3bit)
  63.         sampling rate fFM / (12*priscaler)      fM / 64
  64.         lfo freq                                ( fM*2^(LFRQ/16) ) / (4295*10^6)
  65. */
  66.  
  67. /************************************************************************/
  68. /*    comment of hiro-shi(Hiromitsu Shioya)                             */
  69. /*    YM2610(B) = (OPN-B                                                */
  70. /*    YM2610  : PSG:3ch FM:4ch ADPCM(18.5KHz):6ch DeltaT ADPCM:1ch      */
  71. /*    YM2610B : PSG:3ch FM:6ch ADPCM(18.5KHz):6ch DeltaT ADPCM:1ch      */
  72. /************************************************************************/
  73.  
  74. #include <stdio.h>
  75. #include <stdlib.h>
  76. #include <string.h>
  77. #include <stdarg.h>
  78. #include <math.h>
  79. #ifndef __RAINE__
  80. #include "driver.h"        /* use M.A.M.E. */
  81. #else
  82. #include "deftypes.h"        /* use RAINE */
  83. #include "support.h"        /* use RAINE */
  84. #endif
  85. #include "ay8910.h"
  86. #include "fm.h"
  87.  
  88. #ifndef PI
  89. #define PI 3.14159265358979323846
  90. #endif
  91.  
  92. /***** shared function building option ****/
  93. #define BUILD_OPN (BUILD_YM2203||BUILD_YM2608||BUILD_YM2610||BUILD_YM2612)
  94. #define BUILD_OPNB (BUILD_YM2610||BUILD_YM2610B)
  95. #define BUILD_FM_ADPCMA (BUILD_YM2608||BUILD_OPNB)
  96. #define BUILD_FM_ADPCMB (BUILD_YM2608||BUILD_OPNB)
  97. #define BUILD_STEREO (BUILD_YM2608||BUILD_YM2610||BUILD_YM2612||BUILD_YM2151)
  98. #define BUILD_LFO (BUILD_YM2608||BUILD_YM2610||BUILD_YM2612||BUILD_YM2151)
  99.  
  100. #if BUILD_FM_ADPCMB
  101. /* include external DELTA-T ADPCM unit */
  102.   #include "ymdeltat.h"        /* DELTA-T ADPCM UNIT */
  103.   #define DELTAT_MIXING_LEVEL (4) /* DELTA-T ADPCM MIXING LEVEL */
  104. #endif
  105.  
  106. /* -------------------- sound quality define selection --------------------- */
  107. /* sinwave entries */
  108. /* used static memory = SIN_ENT * 4 (byte) */
  109. #define SIN_ENT 2048
  110.  
  111. /* lower bits of envelope counter */
  112. #define ENV_BITS 16
  113.  
  114. /* envelope output entries */
  115. #define EG_ENT   4096
  116. #define EG_STEP (96.0/EG_ENT) /* OPL == 0.1875 dB */
  117.  
  118. #if FM_LFO_SUPPORT
  119. /* LFO table entries */
  120. #define LFO_ENT 512
  121. #define LFO_SHIFT (32-9)
  122. #define LFO_RATE 0x10000
  123. #endif
  124.  
  125. /* -------------------- preliminary define section --------------------- */
  126. /* attack/decay rate time rate */
  127. #define OPM_ARRATE     399128
  128. #define OPM_DRRATE    5514396
  129. /* It is not checked , because I haven't YM2203 rate */
  130. #define OPN_ARRATE  OPM_ARRATE
  131. #define OPN_DRRATE  OPM_DRRATE
  132.  
  133. /* PG output cut off level : 78dB(14bit)? */
  134. #define PG_CUT_OFF ((int)(78.0/EG_STEP))
  135. /* EG output cut off level : 68dB? */
  136. #define EG_CUT_OFF ((int)(68.0/EG_STEP))
  137.  
  138. #define FREQ_BITS 24        /* frequency turn          */
  139.  
  140. /* PG counter is 21bits @oct.7 */
  141. #define FREQ_RATE   (1<<(FREQ_BITS-21))
  142. #define TL_BITS    (FREQ_BITS+2)
  143. /* OPbit = 14(13+sign) : TL_BITS+1(sign) / output = 16bit */
  144. #define TL_SHIFT (TL_BITS+1-(14-16))
  145.  
  146. /* output final shift */
  147. #define FM_OUTSB  (TL_SHIFT-FM_OUTPUT_BIT)
  148. #define FM_MAXOUT ((1<<(TL_SHIFT-1))-1)
  149. #define FM_MINOUT (-(1<<(TL_SHIFT-1)))
  150.  
  151. /* -------------------- local defines , macros --------------------- */
  152.  
  153. /* envelope counter position */
  154. #define EG_AST   0                    /* start of Attack phase */
  155. #define EG_AED   (EG_ENT<<ENV_BITS)    /* end   of Attack phase */
  156. #define EG_DST   EG_AED                /* start of Decay/Sustain/Release phase */
  157. #define EG_DED   (EG_DST+(EG_ENT<<ENV_BITS)-1)    /* end   of Decay/Sustain/Release phase */
  158. #define EG_OFF   EG_DED                /* off */
  159. #if FM_SEG_SUPPORT
  160. #define EG_UST   ((2*EG_ENT)<<ENV_BITS)  /* start of SEG UPSISE */
  161. #define EG_UED   ((3*EG_ENT)<<ENV_BITS)  /* end of SEG UPSISE */
  162. #endif
  163.  
  164. /* register number to channel number , slot offset */
  165. #define OPN_CHAN(N) (N&3)
  166. #define OPN_SLOT(N) ((N>>2)&3)
  167. #define OPM_CHAN(N) (N&7)
  168. #define OPM_SLOT(N) ((N>>3)&3)
  169. /* slot number */
  170. #define SLOT1 0
  171. #define SLOT2 2
  172. #define SLOT3 1
  173. #define SLOT4 3
  174.  
  175. /* bit0 = Right enable , bit1 = Left enable */
  176. #define OUTD_RIGHT  1
  177. #define OUTD_LEFT   2
  178. #define OUTD_CENTER 3
  179.  
  180. /* FM timer model */
  181. #define FM_TIMER_SINGLE (0)
  182. #define FM_TIMER_INTERVAL (1)
  183.  
  184. /* ---------- OPN / OPM one channel  ---------- */
  185. typedef struct fm_slot {
  186.     INT32 *DT;            /* detune          :DT_TABLE[DT]       */
  187.     int DT2;            /* multiple,Detune2:(DT2<<4)|ML for OPM*/
  188.     int TL;                /* total level     :TL << 8            */
  189.     UINT8 KSR;            /* key scale rate  :3-KSR              */
  190.     const INT32 *AR;    /* attack rate     :&AR_TABLE[AR<<1]   */
  191.     const INT32 *DR;    /* decay rate      :&DR_TABLE[DR<<1]   */
  192.     const INT32 *SR;    /* sustin rate     :&DR_TABLE[SR<<1]   */
  193.     int   SL;            /* sustin level    :SL_TABLE[SL]       */
  194.     const INT32 *RR;    /* release rate    :&DR_TABLE[RR<<2+2] */
  195.     UINT8 SEG;            /* SSG EG type     :SSGEG              */
  196.     UINT8 ksr;            /* key scale rate  :kcode>>(3-KSR)     */
  197.     UINT32 mul;            /* multiple        :ML_TABLE[ML]       */
  198.     /* Phase Generator */
  199.     UINT32 Cnt;            /* frequency count :                   */
  200.     UINT32 Incr;        /* frequency step  :                   */
  201.     /* Envelope Generator */
  202.     void (*eg_next)(struct fm_slot *SLOT);    /* pointer of phase handler */
  203.     INT32 evc;            /* envelope counter                    */
  204.     INT32 eve;            /* envelope counter end point          */
  205.     INT32 evs;            /* envelope counter step               */
  206.     INT32 evsa;            /* envelope step for Attack            */
  207.     INT32 evsd;            /* envelope step for Decay             */
  208.     INT32 evss;            /* envelope step for Sustain           */
  209.     INT32 evsr;            /* envelope step for Release           */
  210.     INT32 TLL;            /* adjusted TotalLevel                 */
  211.     /* LFO */
  212.     UINT8 amon;            /* AMS enable flag              */
  213.     UINT32 ams;            /* AMS depth level of this SLOT */
  214. }FM_SLOT;
  215.  
  216. typedef struct fm_chan {
  217.     FM_SLOT    SLOT[4];
  218.     UINT8 PAN;            /* PAN :NONE,LEFT,RIGHT or CENTER */
  219.     UINT8 ALGO;            /* Algorythm                      */
  220.     UINT8 FB;            /* shift count of self feed back  */
  221.     INT32 op1_out[2];    /* op1 output for beedback        */
  222.     /* Algorythm (connection) */
  223.     INT32 *connect1;        /* pointer of SLOT1 output    */
  224.     INT32 *connect2;        /* pointer of SLOT2 output    */
  225.     INT32 *connect3;        /* pointer of SLOT3 output    */
  226.     INT32 *connect4;        /* pointer of SLOT4 output    */
  227.     /* LFO */
  228.     INT32 pms;                /* PMS depth level of channel */
  229.     UINT32 ams;                /* AMS depth level of channel */
  230.     /* Phase Generator */
  231.     UINT32 fc;            /* fnum,blk    :adjusted to sampling rate */
  232.     UINT8 fn_h;            /* freq latch  :                   */
  233.     UINT8 kcode;        /* key code    :                   */
  234. } FM_CH;
  235.  
  236. /* OPN/OPM common state */
  237. typedef struct fm_state {
  238.     UINT8 index;        /* chip index (number of chip) */
  239.     int clock;            /* master clock  (Hz)  */
  240.     int rate;            /* sampling rate (Hz)  */
  241.     double freqbase;    /* frequency base      */
  242.     double TimerBase;    /* Timer base time     */
  243.     UINT8 address;        /* address register    */
  244.     UINT8 irq;            /* interrupt level     */
  245.     UINT8 irqmask;        /* irq mask            */
  246.     UINT8 status;        /* status flag         */
  247.     UINT32 mode;        /* mode  CSM / 3SLOT   */
  248.     int TA;                /* timer a             */
  249.     int TAC;            /* timer a counter     */
  250.     UINT8 TB;            /* timer b             */
  251.     int TBC;            /* timer b counter     */
  252.     /* speedup customize */
  253.     /* local time tables */
  254.     INT32 DT_TABLE[8][32];    /* DeTune tables       */
  255.     INT32 AR_TABLE[94];        /* Atttack rate tables */
  256.     INT32 DR_TABLE[94];        /* Decay rate tables   */
  257.     /* Extention Timer and IRQ handler */
  258.     FM_TIMERHANDLER    Timer_Handler;
  259.     FM_IRQHANDLER    IRQ_Handler;
  260.     /* timer model single / interval */
  261.     UINT8 timermodel;
  262. }FM_ST;
  263.  
  264. /* -------------------- tables --------------------- */
  265.  
  266. /* sustain lebel table (3db per step) */
  267. /* 0 - 15: 0, 3, 6, 9,12,15,18,21,24,27,30,33,36,39,42,93 (dB)*/
  268. #define SC(db) (int)((db*((3/EG_STEP)*(1<<ENV_BITS)))+EG_DST)
  269. static const int SL_TABLE[16]={
  270.  SC( 0),SC( 1),SC( 2),SC(3 ),SC(4 ),SC(5 ),SC(6 ),SC( 7),
  271.  SC( 8),SC( 9),SC(10),SC(11),SC(12),SC(13),SC(14),SC(31)
  272. };
  273. #undef SC
  274.  
  275. /* size of TL_TABLE = sinwave(max cut_off) + cut_off(tl + ksr + envelope + ams) */
  276. #define TL_MAX (PG_CUT_OFF+EG_CUT_OFF+1)
  277.  
  278. /* TotalLevel : 48 24 12  6  3 1.5 0.75 (dB) */
  279. /* TL_TABLE[ 0      to TL_MAX          ] : plus  section */
  280. /* TL_TABLE[ TL_MAX to TL_MAX+TL_MAX-1 ] : minus section */
  281. static INT32 *TL_TABLE;
  282.  
  283. /* pointers to TL_TABLE with sinwave output offset */
  284. static INT32 *SIN_TABLE[SIN_ENT];
  285.  
  286. /* envelope output curve table */
  287. #if FM_SEG_SUPPORT
  288. /* attack + decay + SSG upside + OFF */
  289. static INT32 ENV_CURVE[3*EG_ENT+1];
  290. #else
  291. /* attack + decay + OFF */
  292. static INT32 ENV_CURVE[2*EG_ENT+1];
  293. #endif
  294. /* envelope counter conversion table when change Decay to Attack phase */
  295. static int DRAR_TABLE[EG_ENT];
  296.  
  297. #define OPM_DTTABLE OPN_DTTABLE
  298. static UINT8 OPN_DTTABLE[4 * 32]={
  299. /* this table is YM2151 and YM2612 data */
  300. /* FD=0 */
  301.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  302.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  303. /* FD=1 */
  304.   0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2,
  305.   2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7, 8, 8, 8, 8,
  306. /* FD=2 */
  307.   1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5,
  308.   5, 6, 6, 7, 8, 8, 9,10,11,12,13,14,16,16,16,16,
  309. /* FD=3 */
  310.   2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7,
  311.   8 , 8, 9,10,11,12,13,14,16,17,19,20,22,22,22,22
  312. };
  313.  
  314. /* multiple table */
  315. #define ML(n) (int)(n*2)
  316. static const int MUL_TABLE[4*16]= {
  317. /* 1/2, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15 */
  318.    ML(0.50),ML( 1.00),ML( 2.00),ML( 3.00),ML( 4.00),ML( 5.00),ML( 6.00),ML( 7.00),
  319.    ML(8.00),ML( 9.00),ML(10.00),ML(11.00),ML(12.00),ML(13.00),ML(14.00),ML(15.00),
  320. /* DT2=1 *SQL(2)   */
  321.    ML(0.71),ML( 1.41),ML( 2.82),ML( 4.24),ML( 5.65),ML( 7.07),ML( 8.46),ML( 9.89),
  322.    ML(11.30),ML(12.72),ML(14.10),ML(15.55),ML(16.96),ML(18.37),ML(19.78),ML(21.20),
  323. /* DT2=2 *SQL(2.5) */
  324.    ML( 0.78),ML( 1.57),ML( 3.14),ML( 4.71),ML( 6.28),ML( 7.85),ML( 9.42),ML(10.99),
  325.    ML(12.56),ML(14.13),ML(15.70),ML(17.27),ML(18.84),ML(20.41),ML(21.98),ML(23.55),
  326. /* DT2=3 *SQL(3)   */
  327.    ML( 0.87),ML( 1.73),ML( 3.46),ML( 5.19),ML( 6.92),ML( 8.65),ML(10.38),ML(12.11),
  328.    ML(13.84),ML(15.57),ML(17.30),ML(19.03),ML(20.76),ML(22.49),ML(24.22),ML(25.95)
  329. };
  330. #undef ML
  331.  
  332. #if FM_LFO_SUPPORT
  333.  
  334. #define PMS_RATE 0x400
  335. /* LFO runtime work */
  336. static UINT32 lfo_amd;
  337. static INT32 lfo_pmd;
  338. #endif
  339.  
  340. /* Dummy table of Attack / Decay rate ( use when rate == 0 ) */
  341. static const INT32 RATE_0[32]=
  342. {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  343.  
  344. /* -------------------- state --------------------- */
  345.  
  346. /* some globals */
  347. #define TYPE_SSG    0x01    /* SSG support          */
  348. #define TYPE_OPN    0x02    /* OPN device           */
  349. #define TYPE_LFOPAN 0x04    /* OPN type LFO and PAN */
  350. #define TYPE_6CH    0x08    /* FM 6CH / 3CH         */
  351. #define TYPE_DAC    0x10    /* YM2612's DAC device  */
  352. #define TYPE_ADPCM  0x20    /* two ADPCM unit       */
  353.  
  354. #define TYPE_YM2203 (TYPE_SSG)
  355. #define TYPE_YM2608 (TYPE_SSG |TYPE_LFOPAN |TYPE_6CH |TYPE_ADPCM)
  356. #define TYPE_YM2610 (TYPE_SSG |TYPE_LFOPAN |TYPE_6CH |TYPE_ADPCM)
  357. #define TYPE_YM2612 (TYPE_6CH |TYPE_LFOPAN |TYPE_DAC)
  358.  
  359. /* current chip state */
  360. static void *cur_chip = 0;        /* pointer of current chip struct */
  361. static FM_ST  *State;            /* basic status */
  362. static FM_CH  *cch[8];            /* pointer of FM channels */
  363. #if FM_LFO_SUPPORT
  364. static UINT32 LFOCnt,LFOIncr;    /* LFO PhaseGenerator */
  365. #endif
  366.  
  367. /* runtime work */
  368. static INT32 out_ch[4];        /* channel output NONE,LEFT,RIGHT or CENTER */
  369. static INT32 pg_in1,pg_in2,pg_in3,pg_in4;    /* PG input of SLOTs */
  370.  
  371. /* -------------------- log output  -------------------- */
  372. /* log output level */
  373. #define LOG_ERR  3      /* ERROR       */
  374. #define LOG_WAR  2      /* WARNING     */
  375. #define LOG_INF  1      /* INFORMATION */
  376. #define LOG_LEVEL LOG_INF
  377.  
  378. #ifndef __RAINE__
  379. #define LOG(n,x) if( (n)>=LOG_LEVEL ) logerror x
  380. #endif
  381.  
  382. /* ----- limitter ----- */
  383. #define Limit(val, max,min) { \
  384.     if ( val > max )      val = max; \
  385.     else if ( val < min ) val = min; \
  386. }
  387.  
  388. /* ----- buffering one of data(STEREO chip) ----- */
  389. #if FM_STEREO_MIX
  390. /* stereo mixing */
  391. #define FM_BUFFERING_STEREO \
  392. {                                                        \
  393.     /* get left & right output with clipping */            \
  394.     out_ch[OUTD_LEFT]  += out_ch[OUTD_CENTER];                \
  395.     Limit( out_ch[OUTD_LEFT] , FM_MAXOUT, FM_MINOUT );    \
  396.     out_ch[OUTD_RIGHT] += out_ch[OUTD_CENTER];                \
  397.     Limit( out_ch[OUTD_RIGHT], FM_MAXOUT, FM_MINOUT );    \
  398.     /* buffering */                                        \
  399.     *bufL++ = out_ch[OUTD_LEFT] >>FM_OUTSB;                \
  400.     *bufL++ = out_ch[OUTD_RIGHT]>>FM_OUTSB;                \
  401. }
  402. #else
  403. /* stereo separate */
  404. #define FM_BUFFERING_STEREO \
  405. {                                                        \
  406.     /* get left & right output with clipping */            \
  407.     out_ch[OUTD_LEFT]  += out_ch[OUTD_CENTER];                \
  408.     Limit( out_ch[OUTD_LEFT] , FM_MAXOUT, FM_MINOUT );    \
  409.     out_ch[OUTD_RIGHT] += out_ch[OUTD_CENTER];                \
  410.     Limit( out_ch[OUTD_RIGHT], FM_MAXOUT, FM_MINOUT );    \
  411.     /* buffering */                                        \
  412.     bufL[i] = out_ch[OUTD_LEFT] >>FM_OUTSB;                \
  413.     bufR[i] = out_ch[OUTD_RIGHT]>>FM_OUTSB;                \
  414. }
  415. #endif
  416.  
  417. #if FM_INTERNAL_TIMER
  418. /* ----- internal timer mode , update timer */
  419. /* ---------- calcrate timer A ---------- */
  420. #define INTERNAL_TIMER_A(ST,CSM_CH)                    \
  421. {                                                    \
  422.     if( ST->TAC &&  (ST->Timer_Handler==0) )        \
  423.         if( (ST->TAC -= (int)(ST->freqbase*4096)) <= 0 )    \
  424.         {                                            \
  425.             TimerAOver( ST );                        \
  426.             /* CSM mode total level latch and auto key on */    \
  427.             if( ST->mode & 0x80 )                    \
  428.                 CSMKeyControll( CSM_CH );            \
  429.         }                                            \
  430. }
  431. /* ---------- calcrate timer B ---------- */
  432. #define INTERNAL_TIMER_B(ST,step)                        \
  433. {                                                        \
  434.     if( ST->TBC && (ST->Timer_Handler==0) )                \
  435.         if( (ST->TBC -= (int)(ST->freqbase*4096*step)) <= 0 )    \
  436.             TimerBOver( ST );                            \
  437. }
  438. #else /* FM_INTERNAL_TIMER */
  439. /* external timer mode */
  440. #define INTERNAL_TIMER_A(ST,CSM_CH)
  441. #define INTERNAL_TIMER_B(ST,step)
  442. #endif /* FM_INTERNAL_TIMER */
  443.  
  444. /* --------------------- subroutines  --------------------- */
  445. /* status set and IRQ handling */
  446. INLINE void FM_STATUS_SET(FM_ST *ST,int flag)
  447. {
  448.     /* set status flag */
  449.     ST->status |= flag;
  450.     if ( !(ST->irq) && (ST->status & ST->irqmask) )
  451.     {
  452.         ST->irq = 1;
  453.         /* callback user interrupt handler (IRQ is OFF to ON) */
  454.         if(ST->IRQ_Handler) (ST->IRQ_Handler)(ST->index,1);
  455.     }
  456. }
  457.  
  458. /* status reset and IRQ handling */
  459. INLINE void FM_STATUS_RESET(FM_ST *ST,int flag)
  460. {
  461.     /* reset status flag */
  462.     ST->status &=~flag;
  463.     if ( (ST->irq) && !(ST->status & ST->irqmask) )
  464.     {
  465.         ST->irq = 0;
  466.         /* callback user interrupt handler (IRQ is ON to OFF) */
  467.         if(ST->IRQ_Handler) (ST->IRQ_Handler)(ST->index,0);
  468.     }
  469. }
  470.  
  471. /* IRQ mask set */
  472. INLINE void FM_IRQMASK_SET(FM_ST *ST,int flag)
  473. {
  474.     ST->irqmask = flag;
  475.     /* IRQ handling check */
  476.     FM_STATUS_SET(ST,0);
  477.     FM_STATUS_RESET(ST,0);
  478. }
  479.  
  480. /* ---------- event hander of Phase Generator ---------- */
  481.  
  482. /* Release end -> stop counter */
  483. static void FM_EG_Release( FM_SLOT *SLOT )
  484. {
  485.     SLOT->evc = EG_OFF;
  486.     SLOT->eve = EG_OFF+1;
  487.     SLOT->evs = 0;
  488. }
  489.  
  490. /* SUSTAIN end -> stop counter */
  491. static void FM_EG_SR( FM_SLOT *SLOT )
  492. {
  493.     SLOT->evs = 0;
  494.     SLOT->evc = EG_OFF;
  495.     SLOT->eve = EG_OFF+1;
  496. }
  497.  
  498. /* Decay end -> Sustain */
  499. static void FM_EG_DR( FM_SLOT *SLOT )
  500. {
  501.     SLOT->eg_next = FM_EG_SR;
  502.     SLOT->evc = SLOT->SL;
  503.     SLOT->eve = EG_DED;
  504.     SLOT->evs = SLOT->evss;
  505. }
  506.  
  507. /* Attack end -> Decay */
  508. static void FM_EG_AR( FM_SLOT *SLOT )
  509. {
  510.     /* next DR */
  511.     SLOT->eg_next = FM_EG_DR;
  512.     SLOT->evc = EG_DST;
  513.     SLOT->eve = SLOT->SL;
  514.     SLOT->evs = SLOT->evsd;
  515. }
  516.  
  517. #if FM_SEG_SUPPORT
  518. static void FM_EG_SSG_SR( FM_SLOT *SLOT );
  519.  
  520. /* SEG down side end  */
  521. static void FM_EG_SSG_DR( FM_SLOT *SLOT )
  522. {
  523.     if( SLOT->SEG&2){
  524.         /* reverce */
  525.         SLOT->eg_next = FM_EG_SSG_SR;
  526.         SLOT->evc = SLOT->SL + (EG_UST - EG_DST);
  527.         SLOT->eve = EG_UED;
  528.         SLOT->evs = SLOT->evss;
  529.     }else{
  530.         /* again */
  531.         SLOT->evc = EG_DST;
  532.     }
  533.     /* hold */
  534.     if( SLOT->SEG&1) SLOT->evs = 0;
  535. }
  536.  
  537. /* SEG upside side end */
  538. static void FM_EG_SSG_SR( FM_SLOT *SLOT )
  539. {
  540.     if( SLOT->SEG&2){
  541.         /* reverce  */
  542.         SLOT->eg_next = FM_EG_SSG_DR;
  543.         SLOT->evc = EG_DST;
  544.         SLOT->eve = EG_DED;
  545.         SLOT->evs = SLOT->evsd;
  546.     }else{
  547.         /* again */
  548.         SLOT->evc = SLOT->SL + (EG_UST - EG_DST);
  549.     }
  550.     /* hold check */
  551.     if( SLOT->SEG&1) SLOT->evs = 0;
  552. }
  553.  
  554. /* SEG Attack end */
  555. static void FM_EG_SSG_AR( FM_SLOT *SLOT )
  556. {
  557.     if( SLOT->SEG&4){    /* start direction */
  558.         /* next SSG-SR (upside start ) */
  559.         SLOT->eg_next = FM_EG_SSG_SR;
  560.         SLOT->evc = SLOT->SL + (EG_UST - EG_DST);
  561.         SLOT->eve = EG_UED;
  562.         SLOT->evs = SLOT->evss;
  563.     }else{
  564.         /* next SSG-DR (downside start ) */
  565.         SLOT->eg_next = FM_EG_SSG_DR;
  566.         SLOT->evc = EG_DST;
  567.         SLOT->eve = EG_DED;
  568.         SLOT->evs = SLOT->evsd;
  569.     }
  570. }
  571. #endif /* FM_SEG_SUPPORT */
  572.  
  573. /* ----- key on of SLOT ----- */
  574. #define FM_KEY_IS(SLOT) ((SLOT)->eg_next!=FM_EG_Release)
  575.  
  576. INLINE void FM_KEYON(FM_CH *CH , int s )
  577. {
  578.     FM_SLOT *SLOT = &CH->SLOT[s];
  579.     if( !FM_KEY_IS(SLOT) )
  580.     {
  581.         /* restart Phage Generator */
  582.         SLOT->Cnt = 0;
  583.         /* phase -> Attack */
  584. #if FM_SEG_SUPPORT
  585.         if( SLOT->SEG&8 ) SLOT->eg_next = FM_EG_SSG_AR;
  586.         else
  587. #endif
  588.         SLOT->eg_next = FM_EG_AR;
  589.         SLOT->evs     = SLOT->evsa;
  590. #if 0
  591.         /* convert decay count to attack count */
  592.         /* --- This caused the problem by credit sound of paper boy. --- */
  593.         SLOT->evc = EG_AST + DRAR_TABLE[ENV_CURVE[SLOT->evc>>ENV_BITS]];/* + SLOT->evs;*/
  594. #else
  595.         /* reset attack counter */
  596.         SLOT->evc = EG_AST;
  597. #endif
  598.         SLOT->eve = EG_AED;
  599.     }
  600. }
  601. /* ----- key off of SLOT ----- */
  602. INLINE void FM_KEYOFF(FM_CH *CH , int s )
  603. {
  604.     FM_SLOT *SLOT = &CH->SLOT[s];
  605.     if( FM_KEY_IS(SLOT) )
  606.     {
  607.         /* if Attack phase then adjust envelope counter */
  608.         if( SLOT->evc < EG_DST )
  609.             SLOT->evc = (ENV_CURVE[SLOT->evc>>ENV_BITS]<<ENV_BITS) + EG_DST;
  610.         /* phase -> Release */
  611.         SLOT->eg_next = FM_EG_Release;
  612.         SLOT->eve     = EG_DED;
  613.         SLOT->evs     = SLOT->evsr;
  614.     }
  615. }
  616.  
  617. /* setup Algorythm and PAN connection */
  618. static void setup_connection( FM_CH *CH )
  619. {
  620.     INT32 *carrier = &out_ch[CH->PAN]; /* NONE,LEFT,RIGHT or CENTER */
  621.  
  622.     switch( CH->ALGO ){
  623.     case 0:
  624.         /*  PG---S1---S2---S3---S4---OUT */
  625.         CH->connect1 = &pg_in2;
  626.         CH->connect2 = &pg_in3;
  627.         CH->connect3 = &pg_in4;
  628.         break;
  629.     case 1:
  630.         /*  PG---S1-+-S3---S4---OUT */
  631.         /*  PG---S2-+               */
  632.         CH->connect1 = &pg_in3;
  633.         CH->connect2 = &pg_in3;
  634.         CH->connect3 = &pg_in4;
  635.         break;
  636.     case 2:
  637.         /* PG---S1------+-S4---OUT */
  638.         /* PG---S2---S3-+          */
  639.         CH->connect1 = &pg_in4;
  640.         CH->connect2 = &pg_in3;
  641.         CH->connect3 = &pg_in4;
  642.         break;
  643.     case 3:
  644.         /* PG---S1---S2-+-S4---OUT */
  645.         /* PG---S3------+          */
  646.         CH->connect1 = &pg_in2;
  647.         CH->connect2 = &pg_in4;
  648.         CH->connect3 = &pg_in4;
  649.         break;
  650.     case 4:
  651.         /* PG---S1---S2-+--OUT */
  652.         /* PG---S3---S4-+      */
  653.         CH->connect1 = &pg_in2;
  654.         CH->connect2 = carrier;
  655.         CH->connect3 = &pg_in4;
  656.         break;
  657.     case 5:
  658.         /*         +-S2-+     */
  659.         /* PG---S1-+-S3-+-OUT */
  660.         /*         +-S4-+     */
  661.         CH->connect1 = 0;    /* special case */
  662.         CH->connect2 = carrier;
  663.         CH->connect3 = carrier;
  664.         break;
  665.     case 6:
  666.         /* PG---S1---S2-+     */
  667.         /* PG--------S3-+-OUT */
  668.         /* PG--------S4-+     */
  669.         CH->connect1 = &pg_in2;
  670.         CH->connect2 = carrier;
  671.         CH->connect3 = carrier;
  672.         break;
  673.     case 7:
  674.         /* PG---S1-+     */
  675.         /* PG---S2-+-OUT */
  676.         /* PG---S3-+     */
  677.         /* PG---S4-+     */
  678.         CH->connect1 = carrier;
  679.         CH->connect2 = carrier;
  680.         CH->connect3 = carrier;
  681.     }
  682.     CH->connect4 = carrier;
  683. }
  684.  
  685. /* set detune & multiple */
  686. INLINE void set_det_mul(FM_ST *ST,FM_CH *CH,FM_SLOT *SLOT,int v)
  687. {
  688.     SLOT->mul = MUL_TABLE[v&0x0f];
  689.     SLOT->DT  = ST->DT_TABLE[(v>>4)&7];
  690.     CH->SLOT[SLOT1].Incr=-1;
  691. }
  692.  
  693. /* set total level */
  694. INLINE void set_tl(FM_CH *CH,FM_SLOT *SLOT , int v,int csmflag)
  695. {
  696.     v &= 0x7f;
  697.     v = (v<<7)|v; /* 7bit -> 14bit */
  698.     SLOT->TL = (v*EG_ENT)>>14;
  699.     /* if it is not a CSM channel , latch the total level */
  700.     if( !csmflag )
  701.         SLOT->TLL = SLOT->TL;
  702. }
  703.  
  704. /* set attack rate & key scale  */
  705. INLINE void set_ar_ksr(FM_CH *CH,FM_SLOT *SLOT,int v,INT32 *ar_table)
  706. {
  707.     SLOT->KSR  = 3-(v>>6);
  708.     SLOT->AR   = (v&=0x1f) ? &ar_table[v<<1] : RATE_0;
  709.     SLOT->evsa = SLOT->AR[SLOT->ksr];
  710.     if( SLOT->eg_next == FM_EG_AR ) SLOT->evs = SLOT->evsa;
  711.     CH->SLOT[SLOT1].Incr=-1;
  712. }
  713. /* set decay rate */
  714. INLINE void set_dr(FM_SLOT *SLOT,int v,INT32 *dr_table)
  715. {
  716.     SLOT->DR = (v&=0x1f) ? &dr_table[v<<1] : RATE_0;
  717.     SLOT->evsd = SLOT->DR[SLOT->ksr];
  718.     if( SLOT->eg_next == FM_EG_DR ) SLOT->evs = SLOT->evsd;
  719. }
  720. /* set sustain rate */
  721. INLINE void set_sr(FM_SLOT *SLOT,int v,INT32 *dr_table)
  722. {
  723.     SLOT->SR = (v&=0x1f) ? &dr_table[v<<1] : RATE_0;
  724.     SLOT->evss = SLOT->SR[SLOT->ksr];
  725.     if( SLOT->eg_next == FM_EG_SR ) SLOT->evs = SLOT->evss;
  726. }
  727. /* set release rate */
  728. INLINE void set_sl_rr(FM_SLOT *SLOT,int v,INT32 *dr_table)
  729. {
  730.     SLOT->SL = SL_TABLE[(v>>4)];
  731.     SLOT->RR = &dr_table[((v&0x0f)<<2)|2];
  732.     SLOT->evsr = SLOT->RR[SLOT->ksr];
  733.     if( SLOT->eg_next == FM_EG_Release ) SLOT->evs = SLOT->evsr;
  734. }
  735.  
  736. /* operator output calcrator */
  737. #define OP_OUT(PG,EG)   SIN_TABLE[(PG/(0x1000000/SIN_ENT))&(SIN_ENT-1)][EG]
  738. #define OP_OUTN(PG,EG)  NOISE_TABLE[(PG/(0x1000000/SIN_ENT))&(SIN_ENT-1)][EG]
  739.  
  740. /* eg calcration */
  741. #if FM_LFO_SUPPORT
  742. #define FM_CALC_EG(OUT,SLOT)                        \
  743. {                                                    \
  744.     if( (SLOT.evc += SLOT.evs) >= SLOT.eve)         \
  745.         SLOT.eg_next(&(SLOT));                        \
  746.     OUT = SLOT.TLL+ENV_CURVE[SLOT.evc>>ENV_BITS];    \
  747.     if(SLOT.ams)                                    \
  748.         OUT += (SLOT.ams*lfo_amd/LFO_RATE);            \
  749. }
  750. #else
  751. #define FM_CALC_EG(OUT,SLOT)                        \
  752. {                                                    \
  753.     if( (SLOT.evc += SLOT.evs) >= SLOT.eve)         \
  754.         SLOT.eg_next(&(SLOT));                        \
  755.     OUT = SLOT.TLL+ENV_CURVE[SLOT.evc>>ENV_BITS];    \
  756. }
  757. #endif
  758.  
  759. /* ---------- calcrate one of channel ---------- */
  760. INLINE void FM_CALC_CH( FM_CH *CH )
  761. {
  762.     UINT32 eg_out1,eg_out2,eg_out3,eg_out4;  //envelope output
  763.  
  764.     /* Phase Generator */
  765. #if FM_LFO_SUPPORT
  766.     INT32 pms = lfo_pmd * CH->pms / LFO_RATE;
  767.     if(pms)
  768.     {
  769.         pg_in1 = (CH->SLOT[SLOT1].Cnt += CH->SLOT[SLOT1].Incr + (INT32)(pms * CH->SLOT[SLOT1].Incr) / PMS_RATE);
  770.         pg_in2 = (CH->SLOT[SLOT2].Cnt += CH->SLOT[SLOT2].Incr + (INT32)(pms * CH->SLOT[SLOT2].Incr) / PMS_RATE);
  771.         pg_in3 = (CH->SLOT[SLOT3].Cnt += CH->SLOT[SLOT3].Incr + (INT32)(pms * CH->SLOT[SLOT3].Incr) / PMS_RATE);
  772.         pg_in4 = (CH->SLOT[SLOT4].Cnt += CH->SLOT[SLOT4].Incr + (INT32)(pms * CH->SLOT[SLOT4].Incr) / PMS_RATE);
  773.     }
  774.     else
  775. #endif
  776.     {
  777.         pg_in1 = (CH->SLOT[SLOT1].Cnt += CH->SLOT[SLOT1].Incr);
  778.         pg_in2 = (CH->SLOT[SLOT2].Cnt += CH->SLOT[SLOT2].Incr);
  779.         pg_in3 = (CH->SLOT[SLOT3].Cnt += CH->SLOT[SLOT3].Incr);
  780.         pg_in4 = (CH->SLOT[SLOT4].Cnt += CH->SLOT[SLOT4].Incr);
  781.     }
  782.  
  783.     /* Envelope Generator */
  784.     FM_CALC_EG(eg_out1,CH->SLOT[SLOT1]);
  785.     FM_CALC_EG(eg_out2,CH->SLOT[SLOT2]);
  786.     FM_CALC_EG(eg_out3,CH->SLOT[SLOT3]);
  787.     FM_CALC_EG(eg_out4,CH->SLOT[SLOT4]);
  788.  
  789.     /* Connection */
  790.     if( eg_out1 < EG_CUT_OFF )    /* SLOT 1 */
  791.     {
  792.         if( CH->FB ){
  793.             /* with self feed back */
  794.             pg_in1 += (CH->op1_out[0]+CH->op1_out[1])>>CH->FB;
  795.             CH->op1_out[1] = CH->op1_out[0];
  796.         }
  797.         CH->op1_out[0] = OP_OUT(pg_in1,eg_out1);
  798.         /* output slot1 */
  799.         if( !CH->connect1 )
  800.         {
  801.             /* algorythm 5  */
  802.             pg_in2 += CH->op1_out[0];
  803.             pg_in3 += CH->op1_out[0];
  804.             pg_in4 += CH->op1_out[0];
  805.         }else{
  806.             /* other algorythm */
  807.             *CH->connect1 += CH->op1_out[0];
  808.         }
  809.     }
  810.     if( eg_out2 < EG_CUT_OFF )    /* SLOT 2 */
  811.         *CH->connect2 += OP_OUT(pg_in2,eg_out2);
  812.     if( eg_out3 < EG_CUT_OFF )    /* SLOT 3 */
  813.         *CH->connect3 += OP_OUT(pg_in3,eg_out3);
  814.     if( eg_out4 < EG_CUT_OFF )    /* SLOT 4 */
  815.         *CH->connect4 += OP_OUT(pg_in4,eg_out4);
  816. }
  817. /* ---------- frequency counter for operater update ---------- */
  818. INLINE void CALC_FCSLOT(FM_SLOT *SLOT , int fc , int kc )
  819. {
  820.     int ksr;
  821.  
  822.     /* frequency step counter */
  823.     /* SLOT->Incr= (fc+SLOT->DT[kc])*SLOT->mul; */
  824.     SLOT->Incr= fc*SLOT->mul + SLOT->DT[kc];
  825.     ksr = kc >> SLOT->KSR;
  826.     if( SLOT->ksr != ksr )
  827.     {
  828.         SLOT->ksr = ksr;
  829.         /* attack , decay rate recalcration */
  830.         SLOT->evsa = SLOT->AR[ksr];
  831.         SLOT->evsd = SLOT->DR[ksr];
  832.         SLOT->evss = SLOT->SR[ksr];
  833.         SLOT->evsr = SLOT->RR[ksr];
  834.     }
  835. }
  836.  
  837. /* ---------- frequency counter  ---------- */
  838. INLINE void OPN_CALC_FCOUNT(FM_CH *CH )
  839. {
  840.     if( CH->SLOT[SLOT1].Incr==-1){
  841.         int fc = CH->fc;
  842.         int kc = CH->kcode;
  843.         CALC_FCSLOT(&CH->SLOT[SLOT1] , fc , kc );
  844.         CALC_FCSLOT(&CH->SLOT[SLOT2] , fc , kc );
  845.         CALC_FCSLOT(&CH->SLOT[SLOT3] , fc , kc );
  846.         CALC_FCSLOT(&CH->SLOT[SLOT4] , fc , kc );
  847.     }
  848. }
  849.  
  850. /* ----------- initialize time tabls ----------- */
  851. static void init_timetables( FM_ST *ST , UINT8 *DTTABLE , int ARRATE , int DRRATE )
  852. {
  853.     int i,d;
  854.     double rate;
  855.  
  856.     /* DeTune table */
  857.     for (d = 0;d <= 3;d++){
  858.         for (i = 0;i <= 31;i++){
  859.             rate = (double)DTTABLE[d*32 + i] * ST->freqbase * FREQ_RATE;
  860.             ST->DT_TABLE[d][i]   = (INT32) rate;
  861.             ST->DT_TABLE[d+4][i] = (INT32)-rate;
  862.         }
  863.     }
  864.     /* make Attack & Decay tables */
  865.     for (i = 0;i < 4;i++) ST->AR_TABLE[i] = ST->DR_TABLE[i] = 0;
  866.     for (i = 4;i < 64;i++){
  867.         rate  = ST->freqbase;                        /* frequency rate */
  868.         if( i < 60 ) rate *= 1.0+(i&3)*0.25;        /* b0-1 : x1 , x1.25 , x1.5 , x1.75 */
  869.         rate *= 1<<((i>>2)-1);                        /* b2-5 : shift bit */
  870.         rate *= (double)(EG_ENT<<ENV_BITS);
  871.         ST->AR_TABLE[i] = (INT32)(rate / ARRATE);
  872.         ST->DR_TABLE[i] = (INT32)(rate / DRRATE);
  873.     }
  874.     ST->AR_TABLE[62] = EG_AED;
  875.     ST->AR_TABLE[63] = EG_AED;
  876.     for (i = 64;i < 94 ;i++){    /* make for overflow area */
  877.         ST->AR_TABLE[i] = ST->AR_TABLE[63];
  878.         ST->DR_TABLE[i] = ST->DR_TABLE[63];
  879.     }
  880.  
  881. #if 0
  882.     for (i = 0;i < 64 ;i++){
  883.         LOG(LOG_WAR,("rate %2d , ar %f ms , dr %f ms \n",i,
  884.             ((double)(EG_ENT<<ENV_BITS) / ST->AR_TABLE[i]) * (1000.0 / ST->rate),
  885.             ((double)(EG_ENT<<ENV_BITS) / ST->DR_TABLE[i]) * (1000.0 / ST->rate) ));
  886.     }
  887. #endif
  888. }
  889.  
  890. /* ---------- reset one of channel  ---------- */
  891. static void reset_channel( FM_ST *ST , FM_CH *CH , int chan )
  892. {
  893.     int c,s;
  894.  
  895.     ST->mode   = 0;    /* normal mode */
  896.     FM_STATUS_RESET(ST,0xff);
  897.     ST->TA     = 0;
  898.     ST->TAC    = 0;
  899.     ST->TB     = 0;
  900.     ST->TBC    = 0;
  901.  
  902.     for( c = 0 ; c < chan ; c++ )
  903.     {
  904.         CH[c].fc = 0;
  905.         CH[c].PAN = OUTD_CENTER;
  906.         for(s = 0 ; s < 4 ; s++ )
  907.         {
  908.             CH[c].SLOT[s].SEG = 0;
  909.             CH[c].SLOT[s].eg_next= FM_EG_Release;
  910.             CH[c].SLOT[s].evc = EG_OFF;
  911.             CH[c].SLOT[s].eve = EG_OFF+1;
  912.             CH[c].SLOT[s].evs = 0;
  913.         }
  914.     }
  915. }
  916.  
  917. /* ---------- generic table initialize ---------- */
  918. static int FMInitTable( void )
  919. {
  920.     int s,t;
  921.     double rate;
  922.     int i,j;
  923.     double pom;
  924.  
  925.     /* allocate total level table plus+minus section */
  926.     TL_TABLE = (INT32 *)malloc(2*TL_MAX*sizeof(int));
  927.     if( TL_TABLE == 0 ) return 0;
  928.     /* make total level table */
  929.     for (t = 0;t < TL_MAX ;t++){
  930.         if(t >= PG_CUT_OFF)
  931.             rate = 0;    /* under cut off area */
  932.         else
  933.             rate = ((1<<TL_BITS)-1)/pow(10,EG_STEP*t/20);    /* dB -> voltage */
  934.         TL_TABLE[       t] =  (int)rate;
  935.         TL_TABLE[TL_MAX+t] = -TL_TABLE[t];
  936. /*        LOG(LOG_INF,("TotalLevel(%3d) = %x\n",t,TL_TABLE[t]));*/
  937.     }
  938.  
  939.     /* make sinwave table (pointer of total level) */
  940.     for (s = 1;s <= SIN_ENT/4;s++){
  941.         pom = sin(2.0*PI*s/SIN_ENT); /* sin   */
  942.         pom = 20*log10(1/pom);         /* -> decibel */
  943.         j = (int)(pom / EG_STEP);    /* TL_TABLE steps */
  944.         /* cut off check */
  945.         if(j > PG_CUT_OFF)
  946.             j = PG_CUT_OFF;
  947.         /* degree 0   -  90    , degree 180 -  90 : plus section */
  948.         SIN_TABLE[          s] = SIN_TABLE[SIN_ENT/2-s] = &TL_TABLE[j];
  949.         /* degree 180 - 270    , degree 360 - 270 : minus section */
  950.         SIN_TABLE[SIN_ENT/2+s] = SIN_TABLE[SIN_ENT  -s] = &TL_TABLE[TL_MAX+j];
  951.         /* LOG(LOG_INF,("sin(%3d) = %f:%f db\n",s,pom,(double)j * EG_STEP)); */
  952.     }
  953.     /* degree 0 = degree 180                   = off */
  954.     SIN_TABLE[0] = SIN_TABLE[SIN_ENT/2]        = &TL_TABLE[PG_CUT_OFF];
  955.  
  956.     /* envelope counter -> envelope output table */
  957.     for (i=0; i<EG_ENT; i++)
  958.     {
  959.         /* ATTACK curve */
  960.         /* !!!!! preliminary !!!!! */
  961.         pom = pow( ((double)(EG_ENT-1-i)/EG_ENT) , 8 ) * EG_ENT;
  962.         /* if( pom >= EG_ENT ) pom = EG_ENT-1; */
  963.         ENV_CURVE[i] = (int)pom;
  964.         /* DECAY ,RELEASE curve */
  965.         ENV_CURVE[(EG_DST>>ENV_BITS)+i]= i;
  966. #if FM_SEG_SUPPORT
  967.         /* DECAY UPSIDE (SSG ENV) */
  968.         ENV_CURVE[(EG_UST>>ENV_BITS)+i]= EG_ENT-1-i;
  969. #endif
  970.     }
  971.     /* off */
  972.     ENV_CURVE[EG_OFF>>ENV_BITS]= EG_ENT-1;
  973.  
  974.     /* decay to reattack envelope converttable */
  975.     j = EG_ENT-1;
  976.     for (i=0; i<EG_ENT; i++)
  977.     {
  978.         while( j && (ENV_CURVE[j] < i) ) j--;
  979.         DRAR_TABLE[i] = j<<ENV_BITS;
  980.         /* LOG(LOG_INF,("DR %06X = %06X,AR=%06X\n",i,DRAR_TABLE[i],ENV_CURVE[DRAR_TABLE[i]>>ENV_BITS] )); */
  981.     }
  982.     return 1;
  983. }
  984.  
  985.  
  986. static void FMCloseTable( void )
  987. {
  988.     if( TL_TABLE ) free( TL_TABLE );
  989.     return;
  990. }
  991.  
  992. /* OPN/OPM Mode  Register Write */
  993. INLINE void FMSetMode( FM_ST *ST ,int n,int v )
  994. {
  995.     /* b7 = CSM MODE */
  996.     /* b6 = 3 slot mode */
  997.     /* b5 = reset b */
  998.     /* b4 = reset a */
  999.     /* b3 = timer enable b */
  1000.     /* b2 = timer enable a */
  1001.     /* b1 = load b */
  1002.     /* b0 = load a */
  1003.     ST->mode = v;
  1004.  
  1005.     /* reset Timer b flag */
  1006.     if( v & 0x20 )
  1007.         FM_STATUS_RESET(ST,0x02);
  1008.     /* reset Timer a flag */
  1009.     if( v & 0x10 )
  1010.         FM_STATUS_RESET(ST,0x01);
  1011.     /* load b */
  1012.     if( v & 0x02 )
  1013.     {
  1014.         if( ST->TBC == 0 )
  1015.         {
  1016.             ST->TBC = ( 256-ST->TB)<<4;
  1017.             /* External timer handler */
  1018.             if (ST->Timer_Handler) (ST->Timer_Handler)(n,1,ST->TBC,ST->TimerBase);
  1019.         }
  1020.     }else if (ST->timermodel == FM_TIMER_INTERVAL)
  1021.     {    /* stop interbval timer */
  1022.         if( ST->TBC != 0 )
  1023.         {
  1024.             ST->TBC = 0;
  1025.             if (ST->Timer_Handler) (ST->Timer_Handler)(n,1,0,ST->TimerBase);
  1026.         }
  1027.     }
  1028.     /* load a */
  1029.     if( v & 0x01 )
  1030.     {
  1031.         if( ST->TAC == 0 )
  1032.         {
  1033.             ST->TAC = (1024-ST->TA);
  1034.             /* External timer handler */
  1035.             if (ST->Timer_Handler) (ST->Timer_Handler)(n,0,ST->TAC,ST->TimerBase);
  1036.         }
  1037.     }else if (ST->timermodel == FM_TIMER_INTERVAL)
  1038.     {    /* stop interbval timer */
  1039.         if( ST->TAC != 0 )
  1040.         {
  1041.             ST->TAC = 0;
  1042.             if (ST->Timer_Handler) (ST->Timer_Handler)(n,0,0,ST->TimerBase);
  1043.         }
  1044.     }
  1045. }
  1046.  
  1047. /* Timer A Overflow */
  1048. INLINE void TimerAOver(FM_ST *ST)
  1049. {
  1050.     /* status set if enabled */
  1051.     if(ST->mode & 0x04) FM_STATUS_SET(ST,0x01);
  1052.     /* clear or reload the counter */
  1053.     if (ST->timermodel == FM_TIMER_INTERVAL)
  1054.     {
  1055.         ST->TAC = (1024-ST->TA);
  1056.         if (ST->Timer_Handler) (ST->Timer_Handler)(ST->index,0,ST->TAC,ST->TimerBase);
  1057.     }
  1058.     else ST->TAC = 0;
  1059. }
  1060. /* Timer B Overflow */
  1061. INLINE void TimerBOver(FM_ST *ST)
  1062. {
  1063.     /* status set if enabled */
  1064.     if(ST->mode & 0x08) FM_STATUS_SET(ST,0x02);
  1065.     /* clear or reload the counter */
  1066.     if (ST->timermodel == FM_TIMER_INTERVAL)
  1067.     {
  1068.         ST->TBC = ( 256-ST->TB)<<4;
  1069.         if (ST->Timer_Handler) (ST->Timer_Handler)(ST->index,1,ST->TBC,ST->TimerBase);
  1070.     }
  1071.     else ST->TBC = 0;
  1072. }
  1073. /* CSM Key Controll */
  1074. INLINE void CSMKeyControll(FM_CH *CH)
  1075. {
  1076.     /* all key off */
  1077.     /* FM_KEYOFF(CH,SLOT1); */
  1078.     /* FM_KEYOFF(CH,SLOT2); */
  1079.     /* FM_KEYOFF(CH,SLOT3); */
  1080.     /* FM_KEYOFF(CH,SLOT4); */
  1081.     /* total level latch */
  1082.     CH->SLOT[SLOT1].TLL = CH->SLOT[SLOT1].TL;
  1083.     CH->SLOT[SLOT2].TLL = CH->SLOT[SLOT2].TL;
  1084.     CH->SLOT[SLOT3].TLL = CH->SLOT[SLOT3].TL;
  1085.     CH->SLOT[SLOT4].TLL = CH->SLOT[SLOT4].TL;
  1086.     /* all key on */
  1087.     FM_KEYON(CH,SLOT1);
  1088.     FM_KEYON(CH,SLOT2);
  1089.     FM_KEYON(CH,SLOT3);
  1090.     FM_KEYON(CH,SLOT4);
  1091. }
  1092.  
  1093. #if BUILD_OPN
  1094. /***********************************************************/
  1095. /* OPN unit                                                */
  1096. /***********************************************************/
  1097.  
  1098. /* OPN 3slot struct */
  1099. typedef struct opn_3slot {
  1100.     UINT32  fc[3];        /* fnum3,blk3  :calcrated */
  1101.     UINT8 fn_h[3];        /* freq3 latch            */
  1102.     UINT8 kcode[3];        /* key code    :          */
  1103. }FM_3SLOT;
  1104.  
  1105. /* OPN/A/B common state */
  1106. typedef struct opn_f {
  1107.     UINT8 type;        /* chip type         */
  1108.     FM_ST ST;                /* general state     */
  1109.     FM_3SLOT SL3;            /* 3 slot mode state */
  1110.     FM_CH *P_CH;            /* pointer of CH     */
  1111.     UINT32 FN_TABLE[2048]; /* fnumber -> increment counter */
  1112. #if FM_LFO_SUPPORT
  1113.     /* LFO */
  1114.     UINT32 LFOCnt;
  1115.     UINT32 LFOIncr;
  1116.     UINT32 LFO_FREQ[8];/* LFO FREQ table */
  1117. #endif
  1118. } FM_OPN;
  1119.  
  1120. /* OPN key frequency number -> key code follow table */
  1121. /* fnum higher 4bit -> keycode lower 2bit */
  1122. static const UINT8 OPN_FKTABLE[16]={0,0,0,0,0,0,0,1,2,3,3,3,3,3,3,3};
  1123.  
  1124. #if FM_LFO_SUPPORT
  1125. /* OPN LFO waveform table */
  1126. static INT32 OPN_LFO_wave[LFO_ENT];
  1127. #endif
  1128.  
  1129. static int OPNInitTable(void)
  1130. {
  1131.     int i;
  1132.  
  1133. #if FM_LFO_SUPPORT
  1134.     /* LFO wave table */
  1135.     for(i=0;i<LFO_ENT;i++)
  1136.     {
  1137.         OPN_LFO_wave[i]= i<LFO_ENT/2 ? i*LFO_RATE/(LFO_ENT/2) : (LFO_ENT-i)*LFO_RATE/(LFO_ENT/2);
  1138.     }
  1139. #endif
  1140.     return FMInitTable();
  1141. }
  1142.  
  1143. /* ---------- priscaler set(and make time tables) ---------- */
  1144. static void OPNSetPris(FM_OPN *OPN , int pris , int TimerPris, int SSGpris)
  1145. {
  1146.     int i;
  1147.  
  1148.     /* frequency base */
  1149.     OPN->ST.freqbase = (OPN->ST.rate) ? ((double)OPN->ST.clock / OPN->ST.rate) / pris : 0;
  1150.     /* Timer base time */
  1151.     OPN->ST.TimerBase = 1.0/((double)OPN->ST.clock / (double)TimerPris);
  1152.     /* SSG part  priscaler set */
  1153.     if( SSGpris ) SSGClk( OPN->ST.index, OPN->ST.clock * 2 / SSGpris );
  1154.     /* make time tables */
  1155.     init_timetables( &OPN->ST , OPN_DTTABLE , OPN_ARRATE , OPN_DRRATE );
  1156.     /* make fnumber -> increment counter table */
  1157.     for( i=0 ; i < 2048 ; i++ )
  1158.     {
  1159.         /* it is freq table for octave 7 */
  1160.         /* opn freq counter = 20bit */
  1161.         OPN->FN_TABLE[i] = (UINT32)( (double)i * OPN->ST.freqbase * FREQ_RATE * (1<<7) / 2 );
  1162.     }
  1163. #if FM_LFO_SUPPORT
  1164.     /* LFO freq. table */
  1165.     {
  1166.         /* 3.98Hz,5.56Hz,6.02Hz,6.37Hz,6.88Hz,9.63Hz,48.1Hz,72.2Hz @ 8MHz */
  1167. #define FM_LF(Hz) ((double)LFO_ENT*(1<<LFO_SHIFT)*(Hz)/(8000000.0/144))
  1168.         static const double freq_table[8] = { FM_LF(3.98),FM_LF(5.56),FM_LF(6.02),FM_LF(6.37),FM_LF(6.88),FM_LF(9.63),FM_LF(48.1),FM_LF(72.2) };
  1169. #undef FM_LF
  1170.         for(i=0;i<8;i++)
  1171.         {
  1172.             OPN->LFO_FREQ[i] = (UINT32)(freq_table[i] * OPN->ST.freqbase);
  1173.         }
  1174.     }
  1175. #endif
  1176. /*    LOG(LOG_INF,("OPN %d set priscaler %d\n",OPN->ST.index,pris));*/
  1177. }
  1178.  
  1179. /* ---------- write a OPN mode register 0x20-0x2f ---------- */
  1180. static void OPNWriteMode(FM_OPN *OPN, int r, int v)
  1181. {
  1182.     UINT8 c;
  1183.     FM_CH *CH;
  1184.  
  1185.     switch(r){
  1186.     case 0x21:    /* Test */
  1187.         break;
  1188. #if FM_LFO_SUPPORT
  1189.     case 0x22:    /* LFO FREQ (YM2608/YM2612) */
  1190.         if( OPN->type & TYPE_LFOPAN )
  1191.         {
  1192.             OPN->LFOIncr = (v&0x08) ? OPN->LFO_FREQ[v&7] : 0;
  1193.             cur_chip = NULL;
  1194.         }
  1195.         break;
  1196. #endif
  1197.     case 0x24:    /* timer A High 8*/
  1198.         OPN->ST.TA = (OPN->ST.TA & 0x03)|(((int)v)<<2);
  1199.         break;
  1200.     case 0x25:    /* timer A Low 2*/
  1201.         OPN->ST.TA = (OPN->ST.TA & 0x3fc)|(v&3);
  1202.         break;
  1203.     case 0x26:    /* timer B */
  1204.         OPN->ST.TB = v;
  1205.         break;
  1206.     case 0x27:    /* mode , timer controll */
  1207.         FMSetMode( &(OPN->ST),OPN->ST.index,v );
  1208.         break;
  1209.     case 0x28:    /* key on / off */
  1210.         c = v&0x03;
  1211.         if( c == 3 ) break;
  1212.         if( (v&0x04) && (OPN->type & TYPE_6CH) ) c+=3;
  1213.         CH = OPN->P_CH;
  1214.         CH = &CH[c];
  1215.         /* csm mode */
  1216.         /* if( c == 2 && (OPN->ST.mode & 0x80) ) break; */
  1217.         if(v&0x10) FM_KEYON(CH,SLOT1); else FM_KEYOFF(CH,SLOT1);
  1218.         if(v&0x20) FM_KEYON(CH,SLOT2); else FM_KEYOFF(CH,SLOT2);
  1219.         if(v&0x40) FM_KEYON(CH,SLOT3); else FM_KEYOFF(CH,SLOT3);
  1220.         if(v&0x80) FM_KEYON(CH,SLOT4); else FM_KEYOFF(CH,SLOT4);
  1221. /*        LOG(LOG_INF,("OPN %d:%d : KEY %02X\n",n,c,v&0xf0));*/
  1222.         break;
  1223.     }
  1224. }
  1225.  
  1226. /* ---------- write a OPN register (0x30-0xff) ---------- */
  1227. static void OPNWriteReg(FM_OPN *OPN, int r, int v)
  1228. {
  1229.     UINT8 c;
  1230.     FM_CH *CH;
  1231.     FM_SLOT *SLOT;
  1232.  
  1233.     /* 0x30 - 0xff */
  1234.     if( (c = OPN_CHAN(r)) == 3 ) return; /* 0xX3,0xX7,0xXB,0xXF */
  1235.     if( (r >= 0x100) /* && (OPN->type & TYPE_6CH) */ ) c+=3;
  1236.         CH = OPN->P_CH;
  1237.         CH = &CH[c];
  1238.  
  1239.     SLOT = &(CH->SLOT[OPN_SLOT(r)]);
  1240.     switch( r & 0xf0 ) {
  1241.     case 0x30:    /* DET , MUL */
  1242.         set_det_mul(&OPN->ST,CH,SLOT,v);
  1243.         break;
  1244.     case 0x40:    /* TL */
  1245.         set_tl(CH,SLOT,v,(c == 2) && (OPN->ST.mode & 0x80) );
  1246.         break;
  1247.     case 0x50:    /* KS, AR */
  1248.         set_ar_ksr(CH,SLOT,v,OPN->ST.AR_TABLE);
  1249.         break;
  1250.     case 0x60:    /*     DR */
  1251.         /* bit7 = AMS_ON ENABLE(YM2612) */
  1252.         set_dr(SLOT,v,OPN->ST.DR_TABLE);
  1253. #if FM_LFO_SUPPORT
  1254.         if( OPN->type & TYPE_LFOPAN)
  1255.         {
  1256.             SLOT->amon = v>>7;
  1257.             SLOT->ams = CH->ams * SLOT->amon;
  1258.         }
  1259. #endif
  1260.         break;
  1261.     case 0x70:    /*     SR */
  1262.         set_sr(SLOT,v,OPN->ST.DR_TABLE);
  1263.         break;
  1264.     case 0x80:    /* SL, RR */
  1265.         set_sl_rr(SLOT,v,OPN->ST.DR_TABLE);
  1266.         break;
  1267.     case 0x90:    /* SSG-EG */
  1268. #if !FM_SEG_SUPPORT
  1269.         if(v&0x08) LOG(LOG_ERR,("OPN %d,%d,%d :SSG-TYPE envelope selected (not supported )\n",OPN->ST.index,c,OPN_SLOT(r)));
  1270. #endif
  1271.         SLOT->SEG = v&0x0f;
  1272.         break;
  1273.     case 0xa0:
  1274.         switch( OPN_SLOT(r) ){
  1275.         case 0:        /* 0xa0-0xa2 : FNUM1 */
  1276.             {
  1277.                 UINT32 fn  = (((UINT32)( (CH->fn_h)&7))<<8) + v;
  1278.                 UINT8 blk = CH->fn_h>>3;
  1279.                 /* make keyscale code */
  1280.                 CH->kcode = (blk<<2)|OPN_FKTABLE[(fn>>7)];
  1281.                 /* make basic increment counter 32bit = 1 cycle */
  1282.                 CH->fc = OPN->FN_TABLE[fn]>>(7-blk);
  1283.                 CH->SLOT[SLOT1].Incr=-1;
  1284.             }
  1285.             break;
  1286.         case 1:        /* 0xa4-0xa6 : FNUM2,BLK */
  1287.             CH->fn_h = v&0x3f;
  1288.             break;
  1289.         case 2:        /* 0xa8-0xaa : 3CH FNUM1 */
  1290.             if( r < 0x100)
  1291.             {
  1292.                 UINT32 fn  = (((UINT32)(OPN->SL3.fn_h[c]&7))<<8) + v;
  1293.                 UINT8 blk = OPN->SL3.fn_h[c]>>3;
  1294.                 /* make keyscale code */
  1295.                 OPN->SL3.kcode[c]= (blk<<2)|OPN_FKTABLE[(fn>>7)];
  1296.                 /* make basic increment counter 32bit = 1 cycle */
  1297.                 OPN->SL3.fc[c] = OPN->FN_TABLE[fn]>>(7-blk);
  1298.                 (OPN->P_CH)[2].SLOT[SLOT1].Incr=-1;
  1299.             }
  1300.             break;
  1301.         case 3:        /* 0xac-0xae : 3CH FNUM2,BLK */
  1302.             if( r < 0x100)
  1303.                 OPN->SL3.fn_h[c] = v&0x3f;
  1304.             break;
  1305.         }
  1306.         break;
  1307.     case 0xb0:
  1308.         switch( OPN_SLOT(r) ){
  1309.         case 0:        /* 0xb0-0xb2 : FB,ALGO */
  1310.             {
  1311.                 int feedback = (v>>3)&7;
  1312.                 CH->ALGO = v&7;
  1313.                 CH->FB   = feedback ? 8+1 - feedback : 0;
  1314.                 setup_connection( CH );
  1315.             }
  1316.             break;
  1317.         case 1:        /* 0xb4-0xb6 : L , R , AMS , PMS (YM2612/YM2608) */
  1318.             if( OPN->type & TYPE_LFOPAN)
  1319.             {
  1320. #if FM_LFO_SUPPORT
  1321.                 /* b0-2 PMS */
  1322.                 /* 0,3.4,6.7,10,14,20,40,80(cent) */
  1323.                 static const double pmd_table[8]={0,3.4,6.7,10,14,20,40,80};
  1324.                 static const int amd_table[4]={(int)(0/EG_STEP),(int)(1.4/EG_STEP),(int)(5.9/EG_STEP),(int)(11.8/EG_STEP) };
  1325.                 CH->pms = (INT32)( (1.5/1200.0)*pmd_table[v & 7] * PMS_RATE);
  1326.                 /* b4-5 AMS */
  1327.                 /* 0 , 1.4 , 5.9 , 11.8(dB) */
  1328.                 CH->ams = amd_table[(v>>4) & 0x03];
  1329.                 CH->SLOT[SLOT1].ams = CH->ams * CH->SLOT[SLOT1].amon;
  1330.                 CH->SLOT[SLOT2].ams = CH->ams * CH->SLOT[SLOT2].amon;
  1331.                 CH->SLOT[SLOT3].ams = CH->ams * CH->SLOT[SLOT3].amon;
  1332.                 CH->SLOT[SLOT4].ams = CH->ams * CH->SLOT[SLOT4].amon;
  1333. #endif
  1334.                 /* PAN */
  1335.                 CH->PAN = (v>>6)&0x03; /* PAN : b6 = R , b7 = L */
  1336.                 setup_connection( CH );
  1337.                 /* LOG(LOG_INF,("OPN %d,%d : PAN %d\n",n,c,CH->PAN));*/
  1338.             }
  1339.             break;
  1340.         }
  1341.         break;
  1342.     }
  1343. }
  1344. #endif /* BUILD_OPN */
  1345.  
  1346. #if BUILD_YM2203
  1347. /*******************************************************************************/
  1348. /*        YM2203 local section                                                   */
  1349. /*******************************************************************************/
  1350.  
  1351. /* here's the virtual YM2203(OPN) */
  1352. typedef struct ym2203_f {
  1353.     FM_OPN OPN;                /* OPN state         */
  1354.     FM_CH CH[3];            /* channel state     */
  1355. } YM2203;
  1356.  
  1357. static YM2203 *FM2203=NULL;    /* array of YM2203's */
  1358. static int YM2203NumChips;    /* total chip */
  1359.  
  1360. /* ---------- update one of chip ----------- */
  1361. void YM2203UpdateOne(int num, INT16 *buffer, int length)
  1362. {
  1363.     YM2203 *F2203 = &(FM2203[num]);
  1364.     FM_OPN *OPN =   &(FM2203[num].OPN);
  1365.     int i;
  1366.     FM_CH *ch;
  1367.     FMSAMPLE *buf = buffer;
  1368.  
  1369.     cur_chip = (void *)F2203;
  1370.     State = &F2203->OPN.ST;
  1371.     cch[0]   = &F2203->CH[0];
  1372.     cch[1]   = &F2203->CH[1];
  1373.     cch[2]   = &F2203->CH[2];
  1374. #if FM_LFO_SUPPORT
  1375.     /* LFO */
  1376.     lfo_amd = lfo_pmd = 0;
  1377. #endif
  1378.     /* frequency counter channel A */
  1379.     OPN_CALC_FCOUNT( cch[0] );
  1380.     /* frequency counter channel B */
  1381.     OPN_CALC_FCOUNT( cch[1] );
  1382.     /* frequency counter channel C */
  1383.     if( (State->mode & 0xc0) ){
  1384.         /* 3SLOT MODE */
  1385.         if( cch[2]->SLOT[SLOT1].Incr==-1){
  1386.             /* 3 slot mode */
  1387.             CALC_FCSLOT(&cch[2]->SLOT[SLOT1] , OPN->SL3.fc[1] , OPN->SL3.kcode[1] );
  1388.             CALC_FCSLOT(&cch[2]->SLOT[SLOT2] , OPN->SL3.fc[2] , OPN->SL3.kcode[2] );
  1389.             CALC_FCSLOT(&cch[2]->SLOT[SLOT3] , OPN->SL3.fc[0] , OPN->SL3.kcode[0] );
  1390.             CALC_FCSLOT(&cch[2]->SLOT[SLOT4] , cch[2]->fc , cch[2]->kcode );
  1391.         }
  1392.     }else OPN_CALC_FCOUNT( cch[2] );
  1393.  
  1394.     for( i=0; i < length ; i++ )
  1395.     {
  1396.         /*            channel A         channel B         channel C      */
  1397.         out_ch[OUTD_CENTER] = 0;
  1398.         /* calcrate FM */
  1399.         for( ch=cch[0] ; ch <= cch[2] ; ch++)
  1400.             FM_CALC_CH( ch );
  1401.         /* limit check */
  1402.         Limit( out_ch[OUTD_CENTER] , FM_MAXOUT, FM_MINOUT );
  1403.         /* store to sound buffer */
  1404.         buf[i] = out_ch[OUTD_CENTER] >> FM_OUTSB;
  1405.         /* timer controll */
  1406.         INTERNAL_TIMER_A( State , cch[2] )
  1407.     }
  1408.     INTERNAL_TIMER_B(State,length)
  1409. }
  1410.  
  1411. /* ---------- reset one of chip ---------- */
  1412. void YM2203ResetChip(int num)
  1413. {
  1414.     int i;
  1415.     FM_OPN *OPN = &(FM2203[num].OPN);
  1416.  
  1417.     /* Reset Priscaler */
  1418.     OPNSetPris( OPN , 6*12 , 6*12 ,4); /* 1/6 , 1/4 */
  1419.     /* reset SSG section */
  1420.     SSGReset(OPN->ST.index);
  1421.     /* status clear */
  1422.     FM_IRQMASK_SET(&OPN->ST,0x03);
  1423.     OPNWriteMode(OPN,0x27,0x30); /* mode 0 , timer reset */
  1424.     reset_channel( &OPN->ST , FM2203[num].CH , 3 );
  1425.     /* reset OPerator paramater */
  1426.     for(i = 0xb6 ; i >= 0xb4 ; i-- ) OPNWriteReg(OPN,i,0xc0); /* PAN RESET */
  1427.     for(i = 0xb2 ; i >= 0x30 ; i-- ) OPNWriteReg(OPN,i,0);
  1428.     for(i = 0x26 ; i >= 0x20 ; i-- ) OPNWriteReg(OPN,i,0);
  1429. }
  1430.  
  1431. /* ----------  Initialize YM2203 emulator(s) ----------    */
  1432. /* 'num' is the number of virtual YM2203's to allocate     */
  1433. /* 'rate' is sampling rate and 'bufsiz' is the size of the */
  1434. /* buffer that should be updated at each interval          */
  1435. int YM2203Init(int num, int clock, int rate,
  1436.                FM_TIMERHANDLER TimerHandler,FM_IRQHANDLER IRQHandler)
  1437. {
  1438.     int i;
  1439.  
  1440.     if (FM2203) return (-1);    /* duplicate init. */
  1441.     cur_chip = NULL;    /* hiro-shi!! */
  1442.  
  1443.     YM2203NumChips = num;
  1444.  
  1445.     /* allocate ym2203 state space */
  1446.     if( (FM2203 = (YM2203 *)malloc(sizeof(YM2203) * YM2203NumChips))==NULL)
  1447.         return (-1);
  1448.     /* clear */
  1449.     memset(FM2203,0,sizeof(YM2203) * YM2203NumChips);
  1450.     /* allocate total level table (128kb space) */
  1451.     if( !OPNInitTable() )
  1452.     {
  1453.         free( FM2203 );
  1454.         return (-1);
  1455.     }
  1456.     for ( i = 0 ; i < YM2203NumChips; i++ ) {
  1457.         FM2203[i].OPN.ST.index = i;
  1458.         FM2203[i].OPN.type = TYPE_YM2203;
  1459.         FM2203[i].OPN.P_CH = FM2203[i].CH;
  1460.         FM2203[i].OPN.ST.clock = clock;
  1461.         FM2203[i].OPN.ST.rate = rate;
  1462.         /* FM2203[i].OPN.ST.irq = 0; */
  1463.         /* FM2203[i].OPN.ST.satus = 0; */
  1464.         FM2203[i].OPN.ST.timermodel = FM_TIMER_INTERVAL;
  1465.         /* Extend handler */
  1466.         FM2203[i].OPN.ST.Timer_Handler = TimerHandler;
  1467.         FM2203[i].OPN.ST.IRQ_Handler   = IRQHandler;
  1468.         YM2203ResetChip(i);
  1469.     }
  1470.     return(0);
  1471. }
  1472.  
  1473. /* ---------- shut down emurator ----------- */
  1474. void YM2203Shutdown(void)
  1475. {
  1476.     if (!FM2203) return;
  1477.  
  1478.     FMCloseTable();
  1479.     free(FM2203);
  1480.     FM2203 = NULL;
  1481. }
  1482.  
  1483. /* ---------- YM2203 I/O interface ---------- */
  1484. int YM2203Write(int n,int a,UINT8 v)
  1485. {
  1486.     FM_OPN *OPN = &(FM2203[n].OPN);
  1487.  
  1488.     if( !(a&1) )
  1489.     {    /* address port */
  1490.         OPN->ST.address = v & 0xff;
  1491.         /* Write register to SSG emurator */
  1492.         if( v < 16 ) SSGWrite(n,0,v);
  1493.         switch(OPN->ST.address)
  1494.         {
  1495.         case 0x2d:    /* divider sel */
  1496.             OPNSetPris( OPN, 6*12, 6*12 ,4); /* OPN 1/6 , SSG 1/4 */
  1497.             break;
  1498.         case 0x2e:    /* divider sel */
  1499.             OPNSetPris( OPN, 3*12, 3*12,2); /* OPN 1/3 , SSG 1/2 */
  1500.             break;
  1501.         case 0x2f:    /* divider sel */
  1502.             OPNSetPris( OPN, 2*12, 2*12,1); /* OPN 1/2 , SSG 1/1 */
  1503.             break;
  1504.         }
  1505.     }
  1506.     else
  1507.     {    /* data port */
  1508.         int addr = OPN->ST.address;
  1509.         switch( addr & 0xf0 )
  1510.         {
  1511.         case 0x00:    /* 0x00-0x0f : SSG section */
  1512.             /* Write data to SSG emurator */
  1513.             SSGWrite(n,a,v);
  1514.             break;
  1515.         case 0x20:    /* 0x20-0x2f : Mode section */
  1516.             YM2203UpdateReq(n);
  1517.             /* write register */
  1518.              OPNWriteMode(OPN,addr,v);
  1519.             break;
  1520.         default:    /* 0x30-0xff : OPN section */
  1521.             YM2203UpdateReq(n);
  1522.             /* write register */
  1523.              OPNWriteReg(OPN,addr,v);
  1524.         }
  1525.     }
  1526.     return OPN->ST.irq;
  1527. }
  1528.  
  1529. UINT8 YM2203Read(int n,int a)
  1530. {
  1531.     YM2203 *F2203 = &(FM2203[n]);
  1532.     int addr = F2203->OPN.ST.address;
  1533.     int ret = 0;
  1534.  
  1535.     if( !(a&1) )
  1536.     {    /* status port */
  1537.         ret = F2203->OPN.ST.status;
  1538.     }
  1539.     else
  1540.     {    /* data port (ONLY SSG) */
  1541.         if( addr < 16 ) ret = SSGRead(n);
  1542.     }
  1543.     return ret;
  1544. }
  1545.  
  1546. int YM2203TimerOver(int n,int c)
  1547. {
  1548.     YM2203 *F2203 = &(FM2203[n]);
  1549.  
  1550.     if( c )
  1551.     {    /* Timer B */
  1552.         TimerBOver( &(F2203->OPN.ST) );
  1553.     }
  1554.     else
  1555.     {    /* Timer A */
  1556.         YM2203UpdateReq(n);
  1557.         /* timer update */
  1558.         TimerAOver( &(F2203->OPN.ST) );
  1559.         /* CSM mode key,TL controll */
  1560.         if( F2203->OPN.ST.mode & 0x80 )
  1561.         {    /* CSM mode total level latch and auto key on */
  1562.             CSMKeyControll( &(F2203->CH[2]) );
  1563.         }
  1564.     }
  1565.     return F2203->OPN.ST.irq;
  1566. }
  1567.  
  1568. #endif /* BUILD_YM2203 */
  1569.  
  1570. #if (BUILD_YM2608||BUILD_OPNB)
  1571. /* adpcm type A struct */
  1572. typedef struct adpcm_state {
  1573.     UINT8 flag;            /* port state        */
  1574.     UINT8 flagMask;        /* arrived flag mask */
  1575.     UINT8 now_data;
  1576.     UINT32 now_addr;
  1577.     UINT32 now_step;
  1578.     UINT32 step;
  1579.     UINT32 start;
  1580.     UINT32 end;
  1581.     int IL;
  1582.     int volume;                    /* calcrated mixing level */
  1583.     INT32 *pan;                    /* &out_ch[OPN_xxxx] */
  1584.     int /*adpcmm,*/ adpcmx, adpcmd;
  1585.     int adpcml;                    /* hiro-shi!! */
  1586. }ADPCM_CH;
  1587.  
  1588. /* here's the virtual YM2610 */
  1589. typedef struct ym2610_f {
  1590.     FM_OPN OPN;                /* OPN state    */
  1591.     FM_CH CH[6];            /* channel state */
  1592.     int address1;            /* address register1 */
  1593.     /* ADPCM-A unit */
  1594.     UINT8 *pcmbuf;            /* pcm rom buffer */
  1595.     UINT32 pcm_size;            /* size of pcm rom */
  1596.     INT32 *adpcmTL;                    /* adpcmA total level */
  1597.     ADPCM_CH adpcm[6];                /* adpcm channels */
  1598.     UINT32 adpcmreg[0x30];    /* registers */
  1599.     UINT8 adpcm_arrivedEndAddress;
  1600.     /* Delta-T ADPCM unit */
  1601.     YM_DELTAT deltaT;
  1602. } YM2610;
  1603.  
  1604. /* here's the virtual YM2608 */
  1605. typedef YM2610 YM2608;
  1606. #endif /* (BUILD_YM2608||BUILD_OPNB) */
  1607.  
  1608. #if BUILD_FM_ADPCMA
  1609. /***************************************************************/
  1610. /*    ADPCMA units are made by Hiromitsu Shioya (MMSND)         */
  1611. /***************************************************************/
  1612.  
  1613. /**** YM2610 ADPCM defines ****/
  1614. #define ADPCMA_MIXING_LEVEL  (3) /* ADPCMA mixing level   */
  1615. #define ADPCM_SHIFT    (16)      /* frequency step rate   */
  1616. #define ADPCMA_ADDRESS_SHIFT 8   /* adpcm A address shift */
  1617.  
  1618. //#define ADPCMA_DECODE_RANGE 1024
  1619. #define ADPCMA_DECODE_RANGE 2048
  1620. #define ADPCMA_DECODE_MIN (-(ADPCMA_DECODE_RANGE*ADPCMA_MIXING_LEVEL))
  1621. #define ADPCMA_DECODE_MAX ((ADPCMA_DECODE_RANGE*ADPCMA_MIXING_LEVEL)-1)
  1622. #define ADPCMA_VOLUME_DIV 1
  1623.  
  1624. static UINT8 *pcmbufA;
  1625. static UINT32 pcmsizeA;
  1626.  
  1627. /************************************************************/
  1628. /************************************************************/
  1629. /* --------------------- subroutines  --------------------- */
  1630. /************************************************************/
  1631. /************************************************************/
  1632. /************************/
  1633. /*    ADPCM A tables    */
  1634. /************************/
  1635. static int jedi_table[(48+1)*16];
  1636. static int decode_tableA1[16] = {
  1637.   -1*16, -1*16, -1*16, -1*16, 2*16, 5*16, 7*16, 9*16,
  1638.   -1*16, -1*16, -1*16, -1*16, 2*16, 5*16, 7*16, 9*16
  1639. };
  1640.  
  1641. /* 0.9 , 0.9 , 0.9 , 0.9 , 1.2 , 1.6 , 2.0 , 2.4 */
  1642. /* 8 = -1 , 2 5 8 11 */
  1643. /* 9 = -1 , 2 5 9 13 */
  1644. /* 10= -1 , 2 6 10 14 */
  1645. /* 12= -1 , 2 7 12 17 */
  1646. /* 20= -2 , 4 12 20 32 */
  1647.  
  1648. #if 1
  1649. static void InitOPNB_ADPCMATable(void){
  1650.     int step, nib;
  1651.  
  1652.     for (step = 0; step <= 48; step++)
  1653.     {
  1654.         double stepval = floor(16.0 * pow (11.0 / 10.0, (double)step) * ADPCMA_MIXING_LEVEL);
  1655.         /* loop over all nibbles and compute the difference */
  1656.         for (nib = 0; nib < 16; nib++)
  1657.         {
  1658.             int value = (int)stepval*((nib&0x07)*2+1)/8;
  1659.             jedi_table[step*16+nib] = (nib&0x08) ? -value : value;
  1660.         }
  1661.     }
  1662. }
  1663. #else
  1664. static int decode_tableA2[49] = {
  1665.   0x0010, 0x0011, 0x0013, 0x0015, 0x0017, 0x0019, 0x001c, 0x001f,
  1666.   0x0022, 0x0025, 0x0029, 0x002d, 0x0032, 0x0037, 0x003c, 0x0042,
  1667.   0x0049, 0x0050, 0x0058, 0x0061, 0x006b, 0x0076, 0x0082, 0x008f,
  1668.   0x009d, 0x00ad, 0x00be, 0x00d1, 0x00e6, 0x00fd, 0x0117, 0x0133,
  1669.   0x0151, 0x0173, 0x0198, 0x01c1, 0x01ee, 0x0220, 0x0256, 0x0292,
  1670.   0x02d4, 0x031c, 0x036c, 0x03c3, 0x0424, 0x048e, 0x0502, 0x0583,
  1671.   0x0610
  1672. };
  1673. static void InitOPNB_ADPCMATable(void){
  1674.    int ta,tb,tc;
  1675.    for(ta=0;ta<49;ta++){
  1676.      for(tb=0;tb<16;tb++){
  1677.        tc=0;
  1678.        if(tb&0x04){tc+=((decode_tableA2[ta]*ADPCMA_MIXING_LEVEL));}
  1679.        if(tb&0x02){tc+=((decode_tableA2[ta]*ADPCMA_MIXING_LEVEL)>>1);}
  1680.        if(tb&0x01){tc+=((decode_tableA2[ta]*ADPCMA_MIXING_LEVEL)>>2);}
  1681.        tc+=((decode_tableA2[ta]*ADPCMA_MIXING_LEVEL)>>3);
  1682.        if(tb&0x08){tc=(0-tc);}
  1683.        jedi_table[ta*16+tb]=tc;
  1684.      }
  1685.    }
  1686. }
  1687. #endif
  1688.  
  1689. /**** ADPCM A (Non control type) ****/
  1690. INLINE void OPNB_ADPCM_CALC_CHA( YM2610 *F2610, ADPCM_CH *ch )
  1691. {
  1692.     UINT32 step;
  1693.     int data;
  1694.  
  1695.     ch->now_step += ch->step;
  1696.     if ( ch->now_step >= (1<<ADPCM_SHIFT) )
  1697.     {
  1698.         step = ch->now_step >> ADPCM_SHIFT;
  1699.         ch->now_step &= (1<<ADPCM_SHIFT)-1;
  1700.         /* end check */
  1701.         if ( (ch->now_addr+step) > (ch->end<<1) ) {
  1702.             ch->flag = 0;
  1703.             F2610->adpcm_arrivedEndAddress |= ch->flagMask;
  1704.             return;
  1705.         }
  1706.         do{
  1707. #if 0
  1708.             if ( ch->now_addr > (pcmsizeA<<1) ) {
  1709.                 LOG(LOG_WAR,("YM2610: Attempting to play past adpcm rom size!\n" ));
  1710.                 return;
  1711.             }
  1712. #endif
  1713.             if( ch->now_addr&1 ) data = ch->now_data & 0x0f;
  1714.             else
  1715.             {
  1716.                 ch->now_data = *(pcmbufA+(ch->now_addr>>1));
  1717.                 data = (ch->now_data >> 4)&0x0f;
  1718.             }
  1719.             ch->now_addr++;
  1720.  
  1721.             ch->adpcmx += jedi_table[ch->adpcmd+data];
  1722.             Limit( ch->adpcmx,ADPCMA_DECODE_MAX, ADPCMA_DECODE_MIN );
  1723.             ch->adpcmd += decode_tableA1[data];
  1724.             Limit( ch->adpcmd, 48*16, 0*16 );
  1725.             /**** calc pcm * volume data ****/
  1726.             ch->adpcml = ch->adpcmx * ch->volume;
  1727.         }while(--step);
  1728.     }
  1729.     /* output for work of output channels (out_ch[OPNxxxx])*/
  1730.     *(ch->pan) += ch->adpcml;
  1731. }
  1732.  
  1733. /* ADPCM type A */
  1734. static void FM_ADPCMAWrite(YM2610 *F2610,int r,int v)
  1735. {
  1736.     ADPCM_CH *adpcm = F2610->adpcm;
  1737.     UINT8 c = r&0x07;
  1738.  
  1739.     F2610->adpcmreg[r] = v&0xff; /* stock data */
  1740.     switch( r ){
  1741.     case 0x00: /* DM,--,C5,C4,C3,C2,C1,C0 */
  1742.         /* F2610->port1state = v&0xff; */
  1743.         if( !(v&0x80) ){
  1744.             /* KEY ON */
  1745.             for( c = 0; c < 6; c++ ){
  1746.                 if( (1<<c)&v ){
  1747.                     /**** start adpcm ****/
  1748.                     adpcm[c].step     = (UINT32)((float)(1<<ADPCM_SHIFT)*((float)F2610->OPN.ST.freqbase)/3.0);
  1749.                     adpcm[c].now_addr = adpcm[c].start<<1;
  1750.                     adpcm[c].now_step = (1<<ADPCM_SHIFT)-adpcm[c].step;
  1751.                     /*adpcm[c].adpcmm   = 0;*/
  1752.                     adpcm[c].adpcmx   = 0;
  1753.                     adpcm[c].adpcmd   = 0;
  1754.                     adpcm[c].adpcml   = 0;
  1755.                     adpcm[c].flag     = 1;
  1756.                     if(F2610->pcmbuf==NULL){            // Check ROM Mapped
  1757.                         LOG(LOG_WAR,("YM2610: ADPCM-A rom not mapped\n"));
  1758.                         adpcm[c].flag = 0;
  1759.                     } else{
  1760.                         if(adpcm[c].end >= F2610->pcm_size){        // Check End in Range
  1761.                             LOG(LOG_WAR,("YM2610: ADPCM-A end out of range: $%08x\n",adpcm[c].end));
  1762.                             adpcm[c].end = F2610->pcm_size-1;
  1763.                         }
  1764.                         if(adpcm[c].start >= F2610->pcm_size)
  1765.                         {    // Check Start in Range
  1766.                             LOG(LOG_WAR,("YM2610: ADPCM-A start out of range: $%08x\n",adpcm[c].start));
  1767.                             adpcm[c].flag = 0;
  1768.                         }
  1769. /*LOG(LOG_WAR,("YM2610: Start %06X : %02X %02X %02X\n",adpcm[c].start,
  1770. pcmbufA[adpcm[c].start],pcmbufA[adpcm[c].start+1],pcmbufA[adpcm[c].start+2]));*/
  1771.                     }
  1772.                 }    /*** (1<<c)&v ***/
  1773.             }    /**** for loop ****/
  1774.         } else{
  1775.             /* KEY OFF */
  1776.             for( c = 0; c < 6; c++ ){
  1777.                 if( (1<<c)&v )  adpcm[c].flag = 0;
  1778.             }
  1779.         }
  1780.         break;
  1781.     case 0x01:    /* B0-5 = TL 0.75dB step */
  1782.         F2610->adpcmTL = &(TL_TABLE[((v&0x3f)^0x3f)*(int)(0.75/EG_STEP)]);
  1783.         for( c = 0; c < 6; c++ )
  1784.         {
  1785.             adpcm[c].volume = F2610->adpcmTL[adpcm[c].IL*(int)(0.75/EG_STEP)] / ADPCMA_DECODE_RANGE / ADPCMA_VOLUME_DIV;
  1786.             /**** calc pcm * volume data ****/
  1787.             adpcm[c].adpcml = adpcm[c].adpcmx * adpcm[c].volume;
  1788.         }
  1789.         break;
  1790.     default:
  1791.         c = r&0x07;
  1792.         if( c >= 0x06 ) return;
  1793.         switch( r&0x38 ){
  1794.         case 0x08:    /* B7=L,B6=R,B4-0=IL */
  1795.             adpcm[c].IL = (v&0x1f)^0x1f;
  1796.             adpcm[c].volume = F2610->adpcmTL[adpcm[c].IL*(int)(0.75/EG_STEP)] / ADPCMA_DECODE_RANGE / ADPCMA_VOLUME_DIV;
  1797.             adpcm[c].pan    = &out_ch[(v>>6)&0x03];
  1798.             /**** calc pcm * volume data ****/
  1799.             adpcm[c].adpcml = adpcm[c].adpcmx * adpcm[c].volume;
  1800.             break;
  1801.         case 0x10:
  1802.         case 0x18:
  1803.             adpcm[c].start  = ( (F2610->adpcmreg[0x18 + c]*0x0100 | F2610->adpcmreg[0x10 + c]) << ADPCMA_ADDRESS_SHIFT);
  1804.             break;
  1805.         case 0x20:
  1806.         case 0x28:
  1807.             adpcm[c].end    = ( (F2610->adpcmreg[0x28 + c]*0x0100 | F2610->adpcmreg[0x20 + c]) << ADPCMA_ADDRESS_SHIFT);
  1808.             adpcm[c].end   += (1<<ADPCMA_ADDRESS_SHIFT) - 1;
  1809.             break;
  1810.         }
  1811.     }
  1812. }
  1813.  
  1814. #endif /* BUILD_FM_ADPCMA */
  1815.  
  1816. #if BUILD_YM2608
  1817. /*******************************************************************************/
  1818. /*        YM2608 local section                                                   */
  1819. /*******************************************************************************/
  1820. static YM2608 *FM2608=NULL;    /* array of YM2608's */
  1821. static int YM2608NumChips;    /* total chip */
  1822.  
  1823. /* YM2608 Rhythm Number */
  1824. #define RY_BD  0
  1825. #define RY_SD  1
  1826. #define RY_TOP 2
  1827. #define RY_HH  3
  1828. #define RY_TOM 4
  1829. #define RY_RIM 5
  1830.  
  1831. #if 0
  1832. /* Get next pcm data */
  1833. INLINE int YM2608ReadADPCM(int n)
  1834. {
  1835.     YM2608 *F2608 = &(FM2608[n]);
  1836.     if( F2608->ADMode & 0x20 )
  1837.     {    /* buffer memory */
  1838.         /* F2203->OPN.ST.status |= 0x04; */
  1839.         return 0;
  1840.     }
  1841.     else
  1842.     {    /* from PCM data register */
  1843.         FM_STATUS_SET(F2608->OPN.ST,0x08); /* BRDY = 1 */
  1844.         return F2608->ADData;
  1845.     }
  1846. }
  1847.  
  1848. /* Put decoded data */
  1849. INLINE void YM2608WriteADPCM(int n,int v)
  1850. {
  1851.     YM2608 *F2608 = &(FM2608[n]);
  1852.     if( F2608->ADMode & 0x20 )
  1853.     {    /* for buffer */
  1854.         return;
  1855.     }
  1856.     else
  1857.     {    /* for PCM data port */
  1858.         F2608->ADData = v;
  1859.         FM_STATUS_SET(F2608->OPN.ST,0x08) /* BRDY = 1 */
  1860.     }
  1861. }
  1862. #endif
  1863.  
  1864. /* ---------- IRQ flag Controll Write 0x110 ---------- */
  1865. INLINE void YM2608IRQFlagWrite(FM_ST *ST,int n,int v)
  1866. {
  1867.     if( v & 0x80 )
  1868.     {    /* Reset IRQ flag */
  1869.         FM_STATUS_RESET(ST,0xff);
  1870.     }
  1871.     else
  1872.     {    /* Set IRQ mask */
  1873.         /* !!!!!!!!!! pending !!!!!!!!!! */
  1874.     }
  1875. }
  1876.  
  1877. #ifdef YM2608_RHYTHM_PCM
  1878. /**** RYTHM (PCM) ****/
  1879. INLINE void YM2608_RYTHM( YM2608 *F2608, ADPCM_CH *ch )
  1880.  
  1881. {
  1882.     UINT32 step;
  1883.  
  1884.     ch->now_step += ch->step;
  1885.     if ( ch->now_step >= (1<<ADPCM_SHIFT) )
  1886.     {
  1887.         step = ch->now_step >> ADPCM_SHIFT;
  1888.         ch->now_step &= (1<<ADPCM_SHIFT)-1;
  1889.         /* end check */
  1890.         if ( (ch->now_addr+step) > (ch->end<<1) ) {
  1891.             ch->flag = 0;
  1892.             F2608->adpcm_arrivedEndAddress |= ch->flagMask;
  1893.             return;
  1894.         }
  1895.         do{
  1896.             /* get a next pcm data */
  1897.             ch->adpcmx = ((short *)pcmbufA)[ch->now_addr];
  1898.             ch->now_addr++;
  1899.             /**** calc pcm * volume data ****/
  1900.             ch->adpcml = ch->adpcmx * ch->volume;
  1901.         }while(--step);
  1902.     }
  1903.     /* output for work of output channels (out_ch[OPNxxxx])*/
  1904.     *(ch->pan) += ch->adpcml;
  1905. }
  1906. #endif /* YM2608_RHYTHM_PCM */
  1907.  
  1908. /* ---------- update one of chip ----------- */
  1909. void YM2608UpdateOne(int num, INT16 **buffer, int length)
  1910. {
  1911.     YM2608 *F2608 = &(FM2608[num]);
  1912.     FM_OPN *OPN   = &(FM2608[num].OPN);
  1913.     YM_DELTAT *DELTAT = &(F2608[num].deltaT);
  1914.     int i,j;
  1915.     FM_CH *ch;
  1916.     FMSAMPLE  *bufL,*bufR;
  1917.  
  1918.     /* setup DELTA-T unit */
  1919.     YM_DELTAT_DECODE_PRESET(DELTAT);
  1920.     DELTAT->arrivedFlag = 0;    /* ASG */
  1921.     DELTAT->flagMask = 1;    /* ASG */
  1922.  
  1923.     /* set bufer */
  1924.     bufL = buffer[0];
  1925.     bufR = buffer[1];
  1926.  
  1927.     if( (void *)F2608 != cur_chip ){
  1928.         cur_chip = (void *)F2608;
  1929.  
  1930.         State = &OPN->ST;
  1931.         cch[0]   = &F2608->CH[0];
  1932.         cch[1]   = &F2608->CH[1];
  1933.         cch[2]   = &F2608->CH[2];
  1934.         cch[3]   = &F2608->CH[3];
  1935.         cch[4]   = &F2608->CH[4];
  1936.         cch[5]   = &F2608->CH[5];
  1937.         /* setup adpcm rom address */
  1938.         pcmbufA  = F2608->pcmbuf;
  1939.         pcmsizeA = F2608->pcm_size;
  1940. #if FM_LFO_SUPPORT
  1941.         LFOCnt  = OPN->LFOCnt;
  1942.         LFOIncr = OPN->LFOIncr;
  1943.         if( !LFOIncr ) lfo_amd = lfo_pmd = 0;
  1944. #endif
  1945.     }
  1946.     /* update frequency counter */
  1947.     OPN_CALC_FCOUNT( cch[0] );
  1948.     OPN_CALC_FCOUNT( cch[1] );
  1949.     if( (State->mode & 0xc0) ){
  1950.         /* 3SLOT MODE */
  1951.         if( cch[2]->SLOT[SLOT1].Incr==-1){
  1952.             /* 3 slot mode */
  1953.             CALC_FCSLOT(&cch[2]->SLOT[SLOT1] , OPN->SL3.fc[1] , OPN->SL3.kcode[1] );
  1954.             CALC_FCSLOT(&cch[2]->SLOT[SLOT2] , OPN->SL3.fc[2] , OPN->SL3.kcode[2] );
  1955.             CALC_FCSLOT(&cch[2]->SLOT[SLOT3] , OPN->SL3.fc[0] , OPN->SL3.kcode[0] );
  1956.             CALC_FCSLOT(&cch[2]->SLOT[SLOT4] , cch[2]->fc , cch[2]->kcode );
  1957.         }
  1958.     }else OPN_CALC_FCOUNT( cch[2] );
  1959.     OPN_CALC_FCOUNT( cch[3] );
  1960.     OPN_CALC_FCOUNT( cch[4] );
  1961.     OPN_CALC_FCOUNT( cch[5] );
  1962.     /* buffering */
  1963.     for( i=0; i < length ; i++ )
  1964.     {
  1965. #if FM_LFO_SUPPORT
  1966.         /* LFO */
  1967.         if( LFOIncr )
  1968.         {
  1969.             lfo_amd = OPN_LFO_wave[(LFOCnt+=LFOIncr)>>LFO_SHIFT];
  1970.             lfo_pmd = lfo_amd-(LFO_RATE/2);
  1971.         }
  1972. #endif
  1973.         /* clear output acc. */
  1974.         out_ch[OUTD_LEFT] = out_ch[OUTD_RIGHT]= out_ch[OUTD_CENTER] = 0;
  1975.         /**** deltaT ADPCM ****/
  1976.         if( DELTAT->flag )
  1977.             YM_DELTAT_ADPCM_CALC(DELTAT);
  1978.         /* FM */
  1979.         for(ch = cch[0] ; ch <= cch[5] ; ch++)
  1980.             FM_CALC_CH( ch );
  1981.         for( j = 0; j < 6; j++ )
  1982.         {
  1983.             /**** ADPCM ****/
  1984.             if( F2608->adpcm[j].flag )
  1985. #ifdef YM2608_RHYTHM_PCM
  1986.                 YM2608_RYTHM(F2608, &F2608->adpcm[j]);
  1987. #else
  1988.                 OPNB_ADPCM_CALC_CHA( F2608, &F2608->adpcm[j]);
  1989. #endif
  1990.         }
  1991.         /* buffering */
  1992.         FM_BUFFERING_STEREO;
  1993.         /* timer A controll */
  1994.         INTERNAL_TIMER_A( State , cch[2] )
  1995.     }
  1996.     INTERNAL_TIMER_B(State,length)
  1997.     if (DELTAT->arrivedFlag) FM_STATUS_SET(State, 0x04);    /* ASG */
  1998.  
  1999. #if FM_LFO_SUPPORT
  2000.     OPN->LFOCnt = LFOCnt;
  2001. #endif
  2002. }
  2003.  
  2004. /* -------------------------- YM2608(OPNA) ---------------------------------- */
  2005. int YM2608Init(int num, int clock, int rate,
  2006.                void **pcmrom,int *pcmsize,short *rhythmrom,int *rhythmpos,
  2007.                FM_TIMERHANDLER TimerHandler,FM_IRQHANDLER IRQHandler)
  2008. {
  2009.     int i,j;
  2010.  
  2011.     if (FM2608) return (-1);    /* duplicate init. */
  2012.     cur_chip = NULL;    /* hiro-shi!! */
  2013.  
  2014.     YM2608NumChips = num;
  2015.  
  2016.     /* allocate extend state space */
  2017.     if( (FM2608 = (YM2608 *)malloc(sizeof(YM2608) * YM2608NumChips))==NULL)
  2018.         return (-1);
  2019.     /* clear */
  2020.     memset(FM2608,0,sizeof(YM2608) * YM2608NumChips);
  2021.     /* allocate total level table (128kb space) */
  2022.     if( !OPNInitTable() )
  2023.     {
  2024.         free( FM2608 );
  2025.         return (-1);
  2026.     }
  2027.  
  2028.     for ( i = 0 ; i < YM2608NumChips; i++ ) {
  2029.         FM2608[i].OPN.ST.index = i;
  2030.         FM2608[i].OPN.type = TYPE_YM2608;
  2031.         FM2608[i].OPN.P_CH = FM2608[i].CH;
  2032.         FM2608[i].OPN.ST.clock = clock;
  2033.         FM2608[i].OPN.ST.rate = rate;
  2034.         /* FM2608[i].OPN.ST.irq = 0; */
  2035.         /* FM2608[i].OPN.ST.status = 0; */
  2036.         FM2608[i].OPN.ST.timermodel = FM_TIMER_INTERVAL;
  2037.         /* Extend handler */
  2038.         FM2608[i].OPN.ST.Timer_Handler = TimerHandler;
  2039.         FM2608[i].OPN.ST.IRQ_Handler   = IRQHandler;
  2040.         /* DELTA-T */
  2041.         FM2608[i].deltaT.memory = (UINT8 *)(pcmrom[i]);
  2042.         FM2608[i].deltaT.memory_size = pcmsize[i];
  2043.         /* ADPCM(Rythm) */
  2044.         FM2608[i].pcmbuf   = (UINT8 *)rhythmrom;
  2045. #ifdef YM2608_RHYTHM_PCM
  2046.         /* rhythm sound setup (PCM) */
  2047.         for(j=0;j<6;j++)
  2048.         {
  2049.             /* rhythm sound */
  2050.             FM2608[i].adpcm[j].start = rhythmpos[j];
  2051.             FM2608[i].adpcm[j].end   = rhythmpos[j+1]-1;
  2052.         }
  2053.         FM2608[i].pcm_size = rhythmpos[6];
  2054. #else
  2055.         /* rhythm sound setup (ADPCM) */
  2056.         FM2608[i].pcm_size = rhythmsize;
  2057. #endif
  2058.         YM2608ResetChip(i);
  2059.     }
  2060.     InitOPNB_ADPCMATable();
  2061.     return 0;
  2062. }
  2063.  
  2064. /* ---------- shut down emurator ----------- */
  2065. void YM2608Shutdown()
  2066. {
  2067.     if (!FM2608) return;
  2068.  
  2069.     FMCloseTable();
  2070.     free(FM2608);
  2071.     FM2608 = NULL;
  2072. }
  2073.  
  2074. /* ---------- reset one of chip ---------- */
  2075. void YM2608ResetChip(int num)
  2076. {
  2077.     int i;
  2078.     YM2608 *F2608 = &(FM2608[num]);
  2079.     FM_OPN *OPN   = &(FM2608[num].OPN);
  2080.     YM_DELTAT *DELTAT = &(F2608[num].deltaT);
  2081.  
  2082.     /* Reset Priscaler */
  2083.     OPNSetPris( OPN, 6*24, 6*24,4*2); /* OPN 1/6 , SSG 1/4 */
  2084.     /* reset SSG section */
  2085.     SSGReset(OPN->ST.index);
  2086.     /* status clear */
  2087.     FM_IRQMASK_SET(&OPN->ST,0x1f);
  2088.     OPNWriteMode(OPN,0x27,0x30); /* mode 0 , timer reset */
  2089.  
  2090.     /* extend 3ch. disable */
  2091.     //OPN->type &= (~TYPE_6CH);
  2092.  
  2093.     reset_channel( &OPN->ST , F2608->CH , 6 );
  2094.     /* reset OPerator paramater */
  2095.     for(i = 0xb6 ; i >= 0xb4 ; i-- )
  2096.     {
  2097.         OPNWriteReg(OPN,i      ,0xc0);
  2098.         OPNWriteReg(OPN,i|0x100,0xc0);
  2099.     }
  2100.     for(i = 0xb2 ; i >= 0x30 ; i-- )
  2101.     {
  2102.         OPNWriteReg(OPN,i      ,0);
  2103.         OPNWriteReg(OPN,i|0x100,0);
  2104.     }
  2105.     for(i = 0x26 ; i >= 0x20 ; i-- ) OPNWriteReg(OPN,i,0);
  2106.     /* reset ADPCM unit */
  2107.     /**** ADPCM work initial ****/
  2108.     for( i = 0; i < 6+1; i++ ){
  2109.         F2608->adpcm[i].now_addr  = 0;
  2110.         F2608->adpcm[i].now_step  = 0;
  2111.         F2608->adpcm[i].step      = 0;
  2112.         F2608->adpcm[i].start     = 0;
  2113.         F2608->adpcm[i].end       = 0;
  2114.         /* F2608->adpcm[i].delta     = 21866; */
  2115.         F2608->adpcm[i].volume    = 0;
  2116.         F2608->adpcm[i].pan       = &out_ch[OUTD_CENTER]; /* default center */
  2117.         F2608->adpcm[i].flagMask  = (i == 6) ? 0x20 : 0;
  2118.         F2608->adpcm[i].flag      = 0;
  2119.         F2608->adpcm[i].adpcmx    = 0;
  2120.         F2608->adpcm[i].adpcmd    = 127;
  2121.         F2608->adpcm[i].adpcml    = 0;
  2122.     }
  2123.     F2608->adpcmTL = &(TL_TABLE[0x3f*(int)(0.75/EG_STEP)]);
  2124.     /* F2608->port1state = -1; */
  2125.     F2608->adpcm_arrivedEndAddress = 0; /* don't used */
  2126.  
  2127.     /* DELTA-T unit */
  2128.     DELTAT->freqbase = OPN->ST.freqbase;
  2129.     DELTAT->output_pointer = out_ch;
  2130.     DELTAT->portshift = 5;        /* allways 5bits shift */ /* ASG */
  2131.     DELTAT->output_range = DELTAT_MIXING_LEVEL<<TL_BITS;
  2132.     YM_DELTAT_ADPCM_Reset(DELTAT,OUTD_CENTER);
  2133. }
  2134.  
  2135. /* YM2608 write */
  2136. /* n = number  */
  2137. /* a = address */
  2138. /* v = value   */
  2139. int YM2608Write(int n, int a,UINT8 v)
  2140. {
  2141.     YM2608 *F2608 = &(FM2608[n]);
  2142.     FM_OPN *OPN   = &(FM2608[n].OPN);
  2143.     int addr;
  2144.  
  2145.     switch(a&3){
  2146.     case 0:    /* address port 0 */
  2147.         OPN->ST.address = v & 0xff;
  2148.         /* Write register to SSG emurator */
  2149.         if( v < 16 ) SSGWrite(n,0,v);
  2150.         switch(OPN->ST.address)
  2151.         {
  2152.         case 0x2d:    /* divider sel */
  2153.             OPNSetPris( OPN, 6*24, 6*24, 4*2); /* OPN 1/6 , SSG 1/4 */
  2154.             F2608->deltaT.freqbase = OPN->ST.freqbase;
  2155.             break;
  2156.         case 0x2e:    /* divider sel */
  2157.             OPNSetPris( OPN, 3*24, 3*24,2*2); /* OPN 1/3 , SSG 1/2 */
  2158.             F2608->deltaT.freqbase = OPN->ST.freqbase;
  2159.             break;
  2160.         case 0x2f:    /* divider sel */
  2161.             OPNSetPris( OPN, 2*24, 2*24,1*2); /* OPN 1/2 , SSG 1/1 */
  2162.             F2608->deltaT.freqbase = OPN->ST.freqbase;
  2163.             break;
  2164.         }
  2165.         break;
  2166.     case 1:    /* data port 0    */
  2167.         addr = OPN->ST.address;
  2168.         switch(addr & 0xf0)
  2169.         {
  2170.         case 0x00:    /* SSG section */
  2171.             /* Write data to SSG emurator */
  2172.             SSGWrite(n,a,v);
  2173.             break;
  2174.         case 0x10:    /* 0x10-0x1f : Rhythm section */
  2175.             YM2608UpdateReq(n);
  2176.             FM_ADPCMAWrite(F2608,addr-0x10,v);
  2177.             break;
  2178.         case 0x20:    /* Mode Register */
  2179.             switch(addr)
  2180.             {
  2181.             case 0x29: /* SCH,xirq mask */
  2182.                 /* SCH,xx,xxx,EN_ZERO,EN_BRDY,EN_EOS,EN_TB,EN_TA */
  2183.                 /* extend 3ch. enable/disable */
  2184.                 if(v&0x80) OPN->type |= TYPE_6CH;
  2185.                 else       OPN->type &= ~TYPE_6CH;
  2186.                 /* IRQ MASK */
  2187.                 FM_IRQMASK_SET(&OPN->ST,v&0x1f);
  2188.                 break;
  2189.             default:
  2190.                 YM2608UpdateReq(n);
  2191.                 OPNWriteMode(OPN,addr,v);
  2192.             }
  2193.             break;
  2194.         default:    /* OPN section */
  2195.             YM2608UpdateReq(n);
  2196.             OPNWriteReg(OPN,addr,v);
  2197.         }
  2198.         break;
  2199.     case 2:    /* address port 1 */
  2200.         F2608->address1 = v & 0xff;
  2201.         break;
  2202.     case 3:    /* data port 1    */
  2203.         addr = F2608->address1;
  2204.         YM2608UpdateReq(n);
  2205.         switch( addr & 0xf0 )
  2206.         {
  2207.         case 0x00:    /* ADPCM PORT */
  2208.             switch( addr )
  2209.             {
  2210.             case 0x0c:    /* Limit address L */
  2211.                 //F2608->ADLimit = (F2608->ADLimit & 0xff00) | v;
  2212.                 //break;
  2213.             case 0x0d:    /* Limit address H */
  2214.                 //F2608->ADLimit = (F2608->ADLimit & 0x00ff) | (v<<8);
  2215.                 //break;
  2216.             case 0x0e:    /* DAC data */
  2217.                 //break;
  2218.             case 0x0f:    /* PCM data port */
  2219.                 //F2608->ADData = v;
  2220.                 //FM_STATUS_RESET(F2608->OPN.ST,0x08);
  2221.                 break;
  2222.             default:
  2223.                 /* 0x00-0x0b */
  2224.                 YM_DELTAT_ADPCM_Write(&F2608->deltaT,addr,v);
  2225.             }
  2226.             break;
  2227.         case 0x10:    /* IRQ Flag controll */
  2228.             if( addr == 0x10 )
  2229.                 YM2608IRQFlagWrite(&(OPN->ST),n,v);
  2230.             break;
  2231.         default:
  2232.             OPNWriteReg(OPN,addr|0x100,v);
  2233.         }
  2234.     }
  2235.     return OPN->ST.irq;
  2236. }
  2237. UINT8 YM2608Read(int n,int a)
  2238. {
  2239.     YM2608 *F2608 = &(FM2608[n]);
  2240.     int addr = F2608->OPN.ST.address;
  2241.     int ret = 0;
  2242.  
  2243.     switch( a&3 ){
  2244.     case 0:    /* status 0 : YM2203 compatible */
  2245.         /* BUSY:x:x:x:x:x:FLAGB:FLAGA */
  2246.         if(addr==0xff) ret = 0x00; /* ID code */
  2247.         else ret = F2608->OPN.ST.status & 0x83;
  2248.         break;
  2249.     case 1:    /* status 0 */
  2250.         if( addr < 16 ) ret = SSGRead(n);
  2251.         break;
  2252.     case 2:    /* status 1 : + ADPCM status */
  2253.         /* BUSY:x:PCMBUSY:ZERO:BRDY:EOS:FLAGB:FLAGA */
  2254.         if(addr==0xff) ret = 0x00; /* ID code */
  2255.         else ret = F2608->OPN.ST.status | (F2608->adpcm[6].flag ? 0x20 : 0);
  2256.         break;
  2257.     case 3:
  2258.         ret = 0;
  2259.         break;
  2260.     }
  2261.     return ret;
  2262. }
  2263.  
  2264. int YM2608TimerOver(int n,int c)
  2265. {
  2266.     YM2608 *F2608 = &(FM2608[n]);
  2267.  
  2268.     if( c )
  2269.     {    /* Timer B */
  2270.         TimerBOver( &(F2608->OPN.ST) );
  2271.     }
  2272.     else
  2273.     {    /* Timer A */
  2274.         YM2608UpdateReq(n);
  2275.         /* timer update */
  2276.         TimerAOver( &(F2608->OPN.ST) );
  2277.         /* CSM mode key,TL controll */
  2278.         if( F2608->OPN.ST.mode & 0x80 )
  2279.         {    /* CSM mode total level latch and auto key on */
  2280.             CSMKeyControll( &(F2608->CH[2]) );
  2281.         }
  2282.     }
  2283.     return FM2608->OPN.ST.irq;
  2284. }
  2285.  
  2286. #endif /* BUILD_YM2608 */
  2287.  
  2288. #if BUILD_OPNB
  2289. /* -------------------------- YM2610(OPNB) ---------------------------------- */
  2290. static YM2610 *FM2610=NULL;    /* array of YM2610's */
  2291. static int YM2610NumChips;    /* total chip */
  2292.  
  2293. /* ---------- update one of chip (YM2610B FM6: ADPCM-A6: ADPCM-B:1) ----------- */
  2294. void YM2610UpdateOne(int num, INT16 **buffer, int length)
  2295. {
  2296.     YM2610 *F2610 = &(FM2610[num]);
  2297.     FM_OPN *OPN   = &(FM2610[num].OPN);
  2298.     YM_DELTAT *DELTAT = &(F2610[num].deltaT);
  2299.     int i,j;
  2300.     int ch;
  2301.     FMSAMPLE  *bufL,*bufR;
  2302.  
  2303.     /* setup DELTA-T unit */
  2304.     YM_DELTAT_DECODE_PRESET(DELTAT);
  2305.  
  2306.     /* buffer setup */
  2307.     bufL = buffer[0];
  2308.     bufR = buffer[1];
  2309.  
  2310.     if( (void *)F2610 != cur_chip ){
  2311.         cur_chip = (void *)F2610;
  2312.         State = &OPN->ST;
  2313.         cch[0] = &F2610->CH[1];
  2314.         cch[1] = &F2610->CH[2];
  2315.         cch[2] = &F2610->CH[4];
  2316.         cch[3] = &F2610->CH[5];
  2317.         /* setup adpcm rom address */
  2318.         pcmbufA  = F2610->pcmbuf;
  2319.         pcmsizeA = F2610->pcm_size;
  2320. #if FM_LFO_SUPPORT
  2321.         LFOCnt  = OPN->LFOCnt;
  2322.         LFOIncr = OPN->LFOIncr;
  2323.         if( !LFOIncr ) lfo_amd = lfo_pmd = 0;
  2324. #endif
  2325.     }
  2326. #ifdef YM2610B_WARNING
  2327. #define FM_MSG_YM2610B "YM2610-%d.CH%d is playing,Check whether the type of the chip is YM2610B\n"
  2328.     /* Check YM2610B worning message */
  2329.     if( FM_KEY_IS(&F2610->CH[0].SLOT[3]) )
  2330.         LOG(LOG_WAR,(FM_MSG_YM2610B,num,0));
  2331.     if( FM_KEY_IS(&F2610->CH[3].SLOT[3]) )
  2332.         LOG(LOG_WAR,(FM_MSG_YM2610B,num,3));
  2333. #endif
  2334.     /* update frequency counter */
  2335.     OPN_CALC_FCOUNT( cch[0] );
  2336.     if( (State->mode & 0xc0) ){
  2337.         /* 3SLOT MODE */
  2338.         if( cch[1]->SLOT[SLOT1].Incr==-1){
  2339.             /* 3 slot mode */
  2340.             CALC_FCSLOT(&cch[1]->SLOT[SLOT1] , OPN->SL3.fc[1] , OPN->SL3.kcode[1] );
  2341.             CALC_FCSLOT(&cch[1]->SLOT[SLOT2] , OPN->SL3.fc[2] , OPN->SL3.kcode[2] );
  2342.             CALC_FCSLOT(&cch[1]->SLOT[SLOT3] , OPN->SL3.fc[0] , OPN->SL3.kcode[0] );
  2343.             CALC_FCSLOT(&cch[1]->SLOT[SLOT4] , cch[1]->fc , cch[1]->kcode );
  2344.         }
  2345.     }else OPN_CALC_FCOUNT( cch[1] );
  2346.     OPN_CALC_FCOUNT( cch[2] );
  2347.     OPN_CALC_FCOUNT( cch[3] );
  2348.  
  2349.     /* buffering */
  2350.     for( i=0; i < length ; i++ )
  2351.     {
  2352. #if FM_LFO_SUPPORT
  2353.         /* LFO */
  2354.         if( LFOIncr )
  2355.         {
  2356.             lfo_amd = OPN_LFO_wave[(LFOCnt+=LFOIncr)>>LFO_SHIFT];
  2357.             lfo_pmd = lfo_amd-(LFO_RATE/2);
  2358.         }
  2359. #endif
  2360.         /* clear output acc. */
  2361.         out_ch[OUTD_LEFT] = out_ch[OUTD_RIGHT]= out_ch[OUTD_CENTER] = 0;
  2362.         /**** deltaT ADPCM ****/
  2363.         if( DELTAT->flag )
  2364.             YM_DELTAT_ADPCM_CALC(DELTAT);
  2365.         /* FM */
  2366.         for(ch = 0 ; ch < 4 ; ch++)
  2367.             FM_CALC_CH( cch[ch] );
  2368.         for( j = 0; j < 6; j++ )
  2369.         {
  2370.             /**** ADPCM ****/
  2371.             if( F2610->adpcm[j].flag )
  2372.                 OPNB_ADPCM_CALC_CHA( F2610, &F2610->adpcm[j]);
  2373.         }
  2374.         /* buffering */
  2375.         FM_BUFFERING_STEREO;
  2376.         /* timer A controll */
  2377.         INTERNAL_TIMER_A( State , cch[1] )
  2378.     }
  2379.     INTERNAL_TIMER_B(State,length)
  2380. #if FM_LFO_SUPPORT
  2381.     OPN->LFOCnt = LFOCnt;
  2382. #endif
  2383. }
  2384. #endif /* BUILD_OPNB */
  2385.  
  2386. #if BUILD_YM2610B
  2387. /* ---------- update one of chip (YM2610B FM6: ADPCM-A6: ADPCM-B:1) ----------- */
  2388. void YM2610BUpdateOne(int num, INT16 **buffer, int length)
  2389. {
  2390.     YM2610 *F2610 = &(FM2610[num]);
  2391.     FM_OPN *OPN   = &(FM2610[num].OPN);
  2392.     YM_DELTAT *DELTAT = &(FM2610[num].deltaT);
  2393.     int i,j;
  2394.     FM_CH *ch;
  2395.     FMSAMPLE  *bufL,*bufR;
  2396.  
  2397.     /* setup DELTA-T unit */
  2398.     YM_DELTAT_DECODE_PRESET(DELTAT);
  2399.     /* buffer setup */
  2400.     bufL = buffer[0];
  2401.     bufR = buffer[1];
  2402.  
  2403.     if( (void *)F2610 != cur_chip ){
  2404.         cur_chip = (void *)F2610;
  2405.         State = &OPN->ST;
  2406.         cch[0] = &F2610->CH[0];
  2407.         cch[1] = &F2610->CH[1];
  2408.         cch[2] = &F2610->CH[2];
  2409.         cch[3] = &F2610->CH[3];
  2410.         cch[4] = &F2610->CH[4];
  2411.         cch[5] = &F2610->CH[5];
  2412.         /* setup adpcm rom address */
  2413.         pcmbufA  = F2610->pcmbuf;
  2414.         pcmsizeA = F2610->pcm_size;
  2415. #if FM_LFO_SUPPORT
  2416.         LFOCnt  = OPN->LFOCnt;
  2417.         LFOIncr = OPN->LFOIncr;
  2418.         if( !LFOIncr ) lfo_amd = lfo_pmd = 0;
  2419. #endif
  2420.     }
  2421.  
  2422.     /* update frequency counter */
  2423.     OPN_CALC_FCOUNT( cch[0] );
  2424.     OPN_CALC_FCOUNT( cch[1] );
  2425.     if( (State->mode & 0xc0) ){
  2426.         /* 3SLOT MODE */
  2427.         if( cch[2]->SLOT[SLOT1].Incr==-1){
  2428.             /* 3 slot mode */
  2429.             CALC_FCSLOT(&cch[2]->SLOT[SLOT1] , OPN->SL3.fc[1] , OPN->SL3.kcode[1] );
  2430.             CALC_FCSLOT(&cch[2]->SLOT[SLOT2] , OPN->SL3.fc[2] , OPN->SL3.kcode[2] );
  2431.             CALC_FCSLOT(&cch[2]->SLOT[SLOT3] , OPN->SL3.fc[0] , OPN->SL3.kcode[0] );
  2432.             CALC_FCSLOT(&cch[2]->SLOT[SLOT4] , cch[2]->fc , cch[2]->kcode );
  2433.         }
  2434.     }else OPN_CALC_FCOUNT( cch[2] );
  2435.     OPN_CALC_FCOUNT( cch[3] );
  2436.     OPN_CALC_FCOUNT( cch[4] );
  2437.     OPN_CALC_FCOUNT( cch[5] );
  2438.  
  2439.     /* buffering */
  2440.     for( i=0; i < length ; i++ )
  2441.     {
  2442. #if FM_LFO_SUPPORT
  2443.         /* LFO */
  2444.         if( LFOIncr )
  2445.         {
  2446.             lfo_amd = OPN_LFO_wave[(LFOCnt+=LFOIncr)>>LFO_SHIFT];
  2447.             lfo_pmd = lfo_amd-(LFO_RATE/2);
  2448.         }
  2449. #endif
  2450.         /* clear output acc. */
  2451.         out_ch[OUTD_LEFT] = out_ch[OUTD_RIGHT]= out_ch[OUTD_CENTER] = 0;
  2452.         /**** deltaT ADPCM ****/
  2453.         if( DELTAT->flag )
  2454.             YM_DELTAT_ADPCM_CALC(DELTAT);
  2455.         /* FM */
  2456.         for(ch = cch[0] ; ch <= cch[5] ; ch++)
  2457.             FM_CALC_CH( ch );
  2458.         for( j = 0; j < 6; j++ )
  2459.         {
  2460.             /**** ADPCM ****/
  2461.             if( F2610->adpcm[j].flag )
  2462.                 OPNB_ADPCM_CALC_CHA( F2610, &F2610->adpcm[j]);
  2463.         }
  2464.         /* buffering */
  2465.         FM_BUFFERING_STEREO;
  2466.         /* timer A controll */
  2467.         INTERNAL_TIMER_A( State , cch[2] )
  2468.     }
  2469.     INTERNAL_TIMER_B(State,length)
  2470. #if FM_LFO_SUPPORT
  2471.     OPN->LFOCnt = LFOCnt;
  2472. #endif
  2473. }
  2474. #endif /* BUILD_YM2610B */
  2475.  
  2476. #if BUILD_OPNB
  2477. int YM2610Init(int num, int clock, int rate,
  2478.                void **pcmroma,int *pcmsizea,void **pcmromb,int *pcmsizeb,
  2479.                FM_TIMERHANDLER TimerHandler,FM_IRQHANDLER IRQHandler)
  2480.  
  2481. {
  2482.     int i;
  2483.  
  2484.     if (FM2610) return (-1);    /* duplicate init. */
  2485.     cur_chip = NULL;    /* hiro-shi!! */
  2486.  
  2487.     YM2610NumChips = num;
  2488.  
  2489.     /* allocate extend state space */
  2490.     if( (FM2610 = (YM2610 *)malloc(sizeof(YM2610) * YM2610NumChips))==NULL)
  2491.         return (-1);
  2492.     /* clear */
  2493.     memset(FM2610,0,sizeof(YM2610) * YM2610NumChips);
  2494.     /* allocate total level table (128kb space) */
  2495.     if( !OPNInitTable() )
  2496.     {
  2497.         free( FM2610 );
  2498.         return (-1);
  2499.     }
  2500.  
  2501.     for ( i = 0 ; i < YM2610NumChips; i++ ) {
  2502.         /* FM */
  2503.         FM2610[i].OPN.ST.index = i;
  2504.         FM2610[i].OPN.type = TYPE_YM2610;
  2505.         FM2610[i].OPN.P_CH = FM2610[i].CH;
  2506.         FM2610[i].OPN.ST.clock = clock;
  2507.         FM2610[i].OPN.ST.rate = rate;
  2508.         /* FM2610[i].OPN.ST.irq = 0; */
  2509.         /* FM2610[i].OPN.ST.status = 0; */
  2510.         FM2610[i].OPN.ST.timermodel = FM_TIMER_INTERVAL;
  2511.         /* Extend handler */
  2512.         FM2610[i].OPN.ST.Timer_Handler = TimerHandler;
  2513.         FM2610[i].OPN.ST.IRQ_Handler   = IRQHandler;
  2514.         /* ADPCM */
  2515.         FM2610[i].pcmbuf   = (UINT8 *)(pcmroma[i]);
  2516.         FM2610[i].pcm_size = pcmsizea[i];
  2517.         /* DELTA-T */
  2518.         FM2610[i].deltaT.memory = (UINT8 *)(pcmromb[i]);
  2519.         FM2610[i].deltaT.memory_size = pcmsizeb[i];
  2520.         /* */
  2521.         YM2610ResetChip(i);
  2522.     }
  2523.     InitOPNB_ADPCMATable();
  2524.     return 0;
  2525. }
  2526.  
  2527. /* ---------- shut down emurator ----------- */
  2528. void YM2610Shutdown()
  2529. {
  2530.     if (!FM2610) return;
  2531.  
  2532.     FMCloseTable();
  2533.     free(FM2610);
  2534.     FM2610 = NULL;
  2535. }
  2536.  
  2537. /* ---------- reset one of chip ---------- */
  2538. void YM2610ResetChip(int num)
  2539. {
  2540.     int i;
  2541.     YM2610 *F2610 = &(FM2610[num]);
  2542.     FM_OPN *OPN   = &(FM2610[num].OPN);
  2543.     YM_DELTAT *DELTAT = &(FM2610[num].deltaT);
  2544.  
  2545.     /* Reset Priscaler */
  2546.     OPNSetPris( OPN, 6*24, 6*24, 4*2); /* OPN 1/6 , SSG 1/4 */
  2547.     /* reset SSG section */
  2548.     SSGReset(OPN->ST.index);
  2549.     /* status clear */
  2550.     FM_IRQMASK_SET(&OPN->ST,0x03);
  2551.     OPNWriteMode(OPN,0x27,0x30); /* mode 0 , timer reset */
  2552.  
  2553.     reset_channel( &OPN->ST , F2610->CH , 6 );
  2554.     /* reset OPerator paramater */
  2555.     for(i = 0xb6 ; i >= 0xb4 ; i-- )
  2556.     {
  2557.         OPNWriteReg(OPN,i      ,0xc0);
  2558.         OPNWriteReg(OPN,i|0x100,0xc0);
  2559.     }
  2560.     for(i = 0xb2 ; i >= 0x30 ; i-- )
  2561.     {
  2562.         OPNWriteReg(OPN,i      ,0);
  2563.         OPNWriteReg(OPN,i|0x100,0);
  2564.     }
  2565.     for(i = 0x26 ; i >= 0x20 ; i-- ) OPNWriteReg(OPN,i,0);
  2566.     /**** ADPCM work initial ****/
  2567.     for( i = 0; i < 6+1; i++ ){
  2568.         F2610->adpcm[i].now_addr  = 0;
  2569.         F2610->adpcm[i].now_step  = 0;
  2570.         F2610->adpcm[i].step      = 0;
  2571.         F2610->adpcm[i].start     = 0;
  2572.         F2610->adpcm[i].end       = 0;
  2573.         /* F2610->adpcm[i].delta     = 21866; */
  2574.         F2610->adpcm[i].volume    = 0;
  2575.         F2610->adpcm[i].pan       = &out_ch[OUTD_CENTER]; /* default center */
  2576.         F2610->adpcm[i].flagMask  = (i == 6) ? 0x80 : (1<<i);
  2577.         F2610->adpcm[i].flag      = 0;
  2578.         F2610->adpcm[i].adpcmx    = 0;
  2579.         F2610->adpcm[i].adpcmd    = 127;
  2580.         F2610->adpcm[i].adpcml    = 0;
  2581.     }
  2582.     F2610->adpcmTL = &(TL_TABLE[0x3f*(int)(0.75/EG_STEP)]);
  2583.     /* F2610->port1state = -1; */
  2584.     F2610->adpcm_arrivedEndAddress = 0;
  2585.  
  2586.     /* DELTA-T unit */
  2587.     DELTAT->freqbase = OPN->ST.freqbase;
  2588.     DELTAT->output_pointer = out_ch;
  2589.     DELTAT->portshift = 8;        /* allways 8bits shift */
  2590.     DELTAT->output_range = DELTAT_MIXING_LEVEL<<TL_BITS;
  2591.     YM_DELTAT_ADPCM_Reset(DELTAT,OUTD_CENTER);
  2592. }
  2593.  
  2594. /* YM2610 write */
  2595. /* n = number  */
  2596. /* a = address */
  2597. /* v = value   */
  2598. int YM2610Write(int n, int a,UINT8 v)
  2599. {
  2600.     YM2610 *F2610 = &(FM2610[n]);
  2601.     FM_OPN *OPN   = &(FM2610[n].OPN);
  2602.     int addr;
  2603.     int ch;
  2604.  
  2605.     switch( a&3 ){
  2606.     case 0:    /* address port 0 */
  2607.         OPN->ST.address = v & 0xff;
  2608.         /* Write register to SSG emurator */
  2609.         if( v < 16 ) SSGWrite(n,0,v);
  2610.         break;
  2611.     case 1:    /* data port 0    */
  2612.         addr = OPN->ST.address;
  2613.         switch(addr & 0xf0)
  2614.         {
  2615.         case 0x00:    /* SSG section */
  2616.             /* Write data to SSG emurator */
  2617.             SSGWrite(n,a,v);
  2618.             break;
  2619.         case 0x10: /* DeltaT ADPCM */
  2620.             YM2610UpdateReq(n);
  2621.             switch(addr)
  2622.             {
  2623.             case 0x1c: /*  FLAG CONTROL : Extend Status Clear/Mask */
  2624.             {
  2625.                 UINT8 statusmask = ~v;
  2626.                 /* set arrived flag mask */
  2627.                 for(ch=0;ch<6;ch++)
  2628.                     F2610->adpcm[ch].flagMask = statusmask&(1<<ch);
  2629.                 F2610->deltaT.flagMask = statusmask&0x80;
  2630.                 /* clear arrived flag */
  2631.                 F2610->adpcm_arrivedEndAddress &= statusmask&0x3f;
  2632.                 F2610->deltaT.arrivedFlag      &= F2610->deltaT.flagMask;
  2633.             }
  2634.                 break;
  2635.             default:
  2636.                 /* 0x10-0x1b */
  2637.                 YM_DELTAT_ADPCM_Write(&F2610->deltaT,addr-0x10,v);
  2638.             }
  2639.             break;
  2640.         case 0x20:    /* Mode Register */
  2641.             YM2610UpdateReq(n);
  2642.             OPNWriteMode(OPN,addr,v);
  2643.             break;
  2644.         default:    /* OPN section */
  2645.             YM2610UpdateReq(n);
  2646.             /* write register */
  2647.              OPNWriteReg(OPN,addr,v);
  2648.         }
  2649.         break;
  2650.     case 2:    /* address port 1 */
  2651.         F2610->address1 = v & 0xff;
  2652.         break;
  2653.     case 3:    /* data port 1    */
  2654.         YM2610UpdateReq(n);
  2655.         addr = F2610->address1;
  2656.         if( addr < 0x30 )
  2657.             /* 100-12f : ADPCM A section */
  2658.             FM_ADPCMAWrite(F2610,addr,v);
  2659.         else
  2660.             OPNWriteReg(OPN,addr|0x100,v);
  2661.     }
  2662.     return OPN->ST.irq;
  2663. }
  2664. UINT8 YM2610Read(int n,int a)
  2665. {
  2666.     YM2610 *F2610 = &(FM2610[n]);
  2667.     int addr = F2610->OPN.ST.address;
  2668.     UINT8 ret = 0;
  2669.  
  2670.     switch( a&3){
  2671.     case 0:    /* status 0 : YM2203 compatible */
  2672.         ret = F2610->OPN.ST.status & 0x83;
  2673.         break;
  2674.     case 1:    /* data 0 */
  2675.         if( addr < 16 ) ret = SSGRead(n);
  2676.         if( addr == 0xff ) ret = 0x01;
  2677.         break;
  2678.     case 2:    /* status 1 : + ADPCM status */
  2679.         /* ADPCM STATUS (arrived End Address) */
  2680.         /* B,--,A5,A4,A3,A2,A1,A0 */
  2681.         /* B     = ADPCM-B(DELTA-T) arrived end address */
  2682.         /* A0-A5 = ADPCM-A          arrived end address */
  2683.         ret = F2610->adpcm_arrivedEndAddress | F2610->deltaT.arrivedFlag;
  2684.         break;
  2685.     case 3:
  2686.         ret = 0;
  2687.         break;
  2688.     }
  2689.     return ret;
  2690. }
  2691.  
  2692. int YM2610TimerOver(int n,int c)
  2693. {
  2694.     YM2610 *F2610 = &(FM2610[n]);
  2695.  
  2696.     if( c )
  2697.     {    /* Timer B */
  2698.         TimerBOver( &(F2610->OPN.ST) );
  2699.     }
  2700.     else
  2701.     {    /* Timer A */
  2702.         YM2610UpdateReq(n);
  2703.         /* timer update */
  2704.         TimerAOver( &(F2610->OPN.ST) );
  2705.         /* CSM mode key,TL controll */
  2706.         if( F2610->OPN.ST.mode & 0x80 )
  2707.         {    /* CSM mode total level latch and auto key on */
  2708.             CSMKeyControll( &(F2610->CH[2]) );
  2709.         }
  2710.     }
  2711.     return F2610->OPN.ST.irq;
  2712. }
  2713.  
  2714. #endif /* BUILD_OPNB */
  2715.  
  2716.  
  2717. #if BUILD_YM2612
  2718. /*******************************************************************************/
  2719. /*        YM2612 local section                                                   */
  2720. /*******************************************************************************/
  2721. /* here's the virtual YM2612 */
  2722. typedef struct ym2612_f {
  2723.     FM_OPN OPN;                        /* OPN state       */
  2724.     FM_CH CH[6];                    /* channel state */
  2725.     int address1;    /* address register1 */
  2726.     /* dac output (YM2612) */
  2727.     int dacen;
  2728.     int dacout;
  2729. } YM2612;
  2730.  
  2731. static int YM2612NumChips;    /* total chip */
  2732. static YM2612 *FM2612=NULL;    /* array of YM2612's */
  2733.  
  2734. static int dacen;
  2735.  
  2736. /* ---------- update one of chip ----------- */
  2737. void YM2612UpdateOne(int num, INT16 **buffer, int length)
  2738. {
  2739.     YM2612 *F2612 = &(FM2612[num]);
  2740.     FM_OPN *OPN   = &(FM2612[num].OPN);
  2741.     int i;
  2742.     FM_CH *ch,*ech;
  2743.     FMSAMPLE  *bufL,*bufR;
  2744.     int dacout  = F2612->dacout;
  2745.  
  2746.     /* set bufer */
  2747.     bufL = buffer[0];
  2748.     bufR = buffer[1];
  2749.  
  2750.     if( (void *)F2612 != cur_chip ){
  2751.         cur_chip = (void *)F2612;
  2752.  
  2753.         State = &OPN->ST;
  2754.         cch[0]   = &F2612->CH[0];
  2755.         cch[1]   = &F2612->CH[1];
  2756.         cch[2]   = &F2612->CH[2];
  2757.         cch[3]   = &F2612->CH[3];
  2758.         cch[4]   = &F2612->CH[4];
  2759.         cch[5]   = &F2612->CH[5];
  2760.         /* DAC mode */
  2761.         dacen = F2612->dacen;
  2762. #if FM_LFO_SUPPORT
  2763.         LFOCnt  = OPN->LFOCnt;
  2764.         LFOIncr = OPN->LFOIncr;
  2765.         if( !LFOIncr ) lfo_amd = lfo_pmd = 0;
  2766. #endif
  2767.     }
  2768.     /* update frequency counter */
  2769.     OPN_CALC_FCOUNT( cch[0] );
  2770.     OPN_CALC_FCOUNT( cch[1] );
  2771.     if( (State->mode & 0xc0) ){
  2772.         /* 3SLOT MODE */
  2773.         if( cch[2]->SLOT[SLOT1].Incr==-1){
  2774.             /* 3 slot mode */
  2775.             CALC_FCSLOT(&cch[2]->SLOT[SLOT1] , OPN->SL3.fc[1] , OPN->SL3.kcode[1] );
  2776.             CALC_FCSLOT(&cch[2]->SLOT[SLOT2] , OPN->SL3.fc[2] , OPN->SL3.kcode[2] );
  2777.             CALC_FCSLOT(&cch[2]->SLOT[SLOT3] , OPN->SL3.fc[0] , OPN->SL3.kcode[0] );
  2778.             CALC_FCSLOT(&cch[2]->SLOT[SLOT4] , cch[2]->fc , cch[2]->kcode );
  2779.         }
  2780.     }else OPN_CALC_FCOUNT( cch[2] );
  2781.     OPN_CALC_FCOUNT( cch[3] );
  2782.     OPN_CALC_FCOUNT( cch[4] );
  2783.     OPN_CALC_FCOUNT( cch[5] );
  2784.  
  2785.     ech = dacen ? cch[4] : cch[5];
  2786.     /* buffering */
  2787.     for( i=0; i < length ; i++ )
  2788.     {
  2789. #if FM_LFO_SUPPORT
  2790.         /* LFO */
  2791.         if( LFOIncr )
  2792.         {
  2793.             lfo_amd = OPN_LFO_wave[(LFOCnt+=LFOIncr)>>LFO_SHIFT];
  2794.             lfo_pmd = lfo_amd-(LFO_RATE/2);
  2795.         }
  2796. #endif
  2797.         /* clear output acc. */
  2798.         out_ch[OUTD_LEFT] = out_ch[OUTD_RIGHT]= out_ch[OUTD_CENTER] = 0;
  2799.         /* calcrate channel output */
  2800.         for(ch = cch[0] ; ch <= ech ; ch++)
  2801.             FM_CALC_CH( ch );
  2802.         if( dacen )  *cch[5]->connect4 += dacout;
  2803.         /* buffering */
  2804.         FM_BUFFERING_STEREO;
  2805.         /* timer A controll */
  2806.         INTERNAL_TIMER_A( State , cch[2] )
  2807.     }
  2808.     INTERNAL_TIMER_B(State,length)
  2809. #if FM_LFO_SUPPORT
  2810.     OPN->LFOCnt = LFOCnt;
  2811. #endif
  2812. }
  2813.  
  2814. /* -------------------------- YM2612 ---------------------------------- */
  2815. int YM2612Init(int num, int clock, int rate,
  2816.                FM_TIMERHANDLER TimerHandler,FM_IRQHANDLER IRQHandler)
  2817. {
  2818.     int i;
  2819.  
  2820.     if (FM2612) return (-1);    /* duplicate init. */
  2821.     cur_chip = NULL;    /* hiro-shi!! */
  2822.  
  2823.     YM2612NumChips = num;
  2824.  
  2825.     /* allocate extend state space */
  2826.     if( (FM2612 = (YM2612 *)malloc(sizeof(YM2612) * YM2612NumChips))==NULL)
  2827.         return (-1);
  2828.     /* clear */
  2829.     memset(FM2612,0,sizeof(YM2612) * YM2612NumChips);
  2830.     /* allocate total level table (128kb space) */
  2831.     if( !OPNInitTable() )
  2832.     {
  2833.         free( FM2612 );
  2834.         return (-1);
  2835.     }
  2836.  
  2837.     for ( i = 0 ; i < YM2612NumChips; i++ ) {
  2838.         FM2612[i].OPN.ST.index = i;
  2839.         FM2612[i].OPN.type = TYPE_YM2612;
  2840.         FM2612[i].OPN.P_CH = FM2612[i].CH;
  2841.         FM2612[i].OPN.ST.clock = clock;
  2842.         FM2612[i].OPN.ST.rate = rate;
  2843.         /* FM2612[i].OPN.ST.irq = 0; */
  2844.         /* FM2612[i].OPN.ST.status = 0; */
  2845.         FM2612[i].OPN.ST.timermodel = FM_TIMER_INTERVAL;
  2846.         /* Extend handler */
  2847.         FM2612[i].OPN.ST.Timer_Handler = TimerHandler;
  2848.         FM2612[i].OPN.ST.IRQ_Handler   = IRQHandler;
  2849.         YM2612ResetChip(i);
  2850.     }
  2851.     return 0;
  2852. }
  2853.  
  2854. /* ---------- shut down emurator ----------- */
  2855. void YM2612Shutdown()
  2856. {
  2857.     if (!FM2612) return;
  2858.  
  2859.     FMCloseTable();
  2860.     free(FM2612);
  2861.     FM2612 = NULL;
  2862. }
  2863.  
  2864. /* ---------- reset one of chip ---------- */
  2865. void YM2612ResetChip(int num)
  2866. {
  2867.     int i;
  2868.     YM2612 *F2612 = &(FM2612[num]);
  2869.     FM_OPN *OPN   = &(FM2612[num].OPN);
  2870.  
  2871.     OPNSetPris( OPN , 12*12, 12*12, 0);
  2872.     /* status clear */
  2873.     FM_IRQMASK_SET(&OPN->ST,0x03);
  2874.     OPNWriteMode(OPN,0x27,0x30); /* mode 0 , timer reset */
  2875.  
  2876.     reset_channel( &OPN->ST , &F2612->CH[0] , 6 );
  2877.  
  2878.     for(i = 0xb6 ; i >= 0xb4 ; i-- )
  2879.     {
  2880.         OPNWriteReg(OPN,i      ,0xc0);
  2881.         OPNWriteReg(OPN,i|0x100,0xc0);
  2882.     }
  2883.     for(i = 0xb2 ; i >= 0x30 ; i-- )
  2884.     {
  2885.         OPNWriteReg(OPN,i      ,0);
  2886.         OPNWriteReg(OPN,i|0x100,0);
  2887.     }
  2888.     for(i = 0x26 ; i >= 0x20 ; i-- ) OPNWriteReg(OPN,i,0);
  2889.     /* DAC mode clear */
  2890.     F2612->dacen = 0;
  2891. }
  2892.  
  2893. /* YM2612 write */
  2894. /* n = number  */
  2895. /* a = address */
  2896. /* v = value   */
  2897. int YM2612Write(int n, int a,UINT8 v)
  2898. {
  2899.     YM2612 *F2612 = &(FM2612[n]);
  2900.     int addr;
  2901.  
  2902.     switch( a&3){
  2903.     case 0:    /* address port 0 */
  2904.         F2612->OPN.ST.address = v & 0xff;
  2905.         break;
  2906.     case 1:    /* data port 0    */
  2907.         addr = F2612->OPN.ST.address;
  2908.         switch( addr & 0xf0 )
  2909.         {
  2910.         case 0x20:    /* 0x20-0x2f Mode */
  2911.             switch( addr )
  2912.             {
  2913.             case 0x2a:    /* DAC data (YM2612) */
  2914.                 YM2612UpdateReq(n);
  2915.                 F2612->dacout = ((int)v - 0x80)<<(TL_BITS-7);
  2916.                 break;
  2917.             case 0x2b:    /* DAC Sel  (YM2612) */
  2918.                 /* b7 = dac enable */
  2919.                 F2612->dacen = v & 0x80;
  2920.                 cur_chip = NULL;
  2921.                 break;
  2922.             default:    /* OPN section */
  2923.                 YM2612UpdateReq(n);
  2924.                 /* write register */
  2925.                  OPNWriteMode(&(F2612->OPN),addr,v);
  2926.             }
  2927.             break;
  2928.         default:    /* 0x30-0xff OPN section */
  2929.             YM2612UpdateReq(n);
  2930.             /* write register */
  2931.              OPNWriteReg(&(F2612->OPN),addr,v);
  2932.         }
  2933.         break;
  2934.     case 2:    /* address port 1 */
  2935.         F2612->address1 = v & 0xff;
  2936.         break;
  2937.     case 3:    /* data port 1    */
  2938.         addr = F2612->address1;
  2939.         YM2612UpdateReq(n);
  2940.         OPNWriteReg(&(F2612->OPN),addr|0x100,v);
  2941.         break;
  2942.     }
  2943.     return F2612->OPN.ST.irq;
  2944. }
  2945. UINT8 YM2612Read(int n,int a)
  2946. {
  2947.     YM2612 *F2612 = &(FM2612[n]);
  2948.  
  2949.     switch( a&3){
  2950.     case 0:    /* status 0 */
  2951.         return F2612->OPN.ST.status;
  2952.     case 1:
  2953.     case 2:
  2954.     case 3:
  2955.         LOG(LOG_WAR,("YM2612 #%d:A=%d read unmapped area\n"));
  2956.         return F2612->OPN.ST.status;
  2957.     }
  2958.     return 0;
  2959. }
  2960.  
  2961. int YM2612TimerOver(int n,int c)
  2962. {
  2963.     YM2612 *F2612 = &(FM2612[n]);
  2964.  
  2965.     if( c )
  2966.     {    /* Timer B */
  2967.         TimerBOver( &(F2612->OPN.ST) );
  2968.     }
  2969.     else
  2970.     {    /* Timer A */
  2971.         YM2612UpdateReq(n);
  2972.         /* timer update */
  2973.         TimerAOver( &(F2612->OPN.ST) );
  2974.         /* CSM mode key,TL controll */
  2975.         if( F2612->OPN.ST.mode & 0x80 )
  2976.         {    /* CSM mode total level latch and auto key on */
  2977.             CSMKeyControll( &(F2612->CH[2]) );
  2978.         }
  2979.     }
  2980.     return F2612->OPN.ST.irq;
  2981. }
  2982.  
  2983. #endif /* BUILD_YM2612 */
  2984.  
  2985.  
  2986. #if BUILD_YM2151
  2987. /*******************************************************************************/
  2988. /*        YM2151 local section                                                   */
  2989. /*******************************************************************************/
  2990. /* -------------------------- OPM ---------------------------------- */
  2991. #undef  FM_SEG_SUPPORT
  2992. #define FM_SEG_SUPPORT 0    /* OPM has not SEG type envelope */
  2993.  
  2994. /* here's the virtual YM2151(OPM)  */
  2995. typedef struct ym2151_f {
  2996.     FM_ST ST;                    /* general state     */
  2997.     FM_CH CH[8];                /* channel state     */
  2998.     UINT8 ct;                    /* CT0,1             */
  2999.     UINT32 NoiseCnt;            /* noise generator   */
  3000.     UINT32 NoiseIncr;            /* noise mode enable & step */
  3001. #if FM_LFO_SUPPORT
  3002.     /* LFO */
  3003.     UINT32 LFOCnt;
  3004.     UINT32 LFOIncr;
  3005.     UINT8 pmd;                    /* LFO pmd level     */
  3006.     UINT8 amd;                    /* LFO amd level     */
  3007.     INT32 *wavetype;            /* LFO waveform      */
  3008.     UINT8 testreg;                /* test register (LFO reset) */
  3009. #endif
  3010.     UINT32 KC_TABLE[8*12*64+950];/* keycode,keyfunction -> count */
  3011.     mem_write_handler PortWrite;/*  callback when write CT0/CT1 */
  3012. } YM2151;
  3013.  
  3014. static YM2151 *FMOPM=NULL;    /* array of YM2151's */
  3015. static int YM2151NumChips;    /* total chip */
  3016.  
  3017. #if FM_LFO_SUPPORT
  3018. static INT32 OPM_LFO_waves[LFO_ENT*4];    /* LFO wave tabel    */
  3019. static INT32 *OPM_LFO_wave;
  3020. #endif
  3021.  
  3022. /* current chip state */
  3023. static UINT32 NoiseCnt , NoiseIncr;
  3024.  
  3025. static INT32 *NOISE_TABLE[SIN_ENT];
  3026.  
  3027. static const int DT2_TABLE[4]={ /* 4 DT2 values */
  3028. /*
  3029.  *   DT2 defines offset in cents from base note
  3030.  *
  3031.  *   The table below defines offset in deltas table...
  3032.  *   User's Manual page 22
  3033.  *   Values below were calculated using formula:  value = orig.val * 1.5625
  3034.  *
  3035.  * DT2=0 DT2=1 DT2=2 DT2=3
  3036.  * 0     600   781   950
  3037.  */
  3038.     0,    384,  500,  608
  3039. };
  3040.  
  3041. static const int KC_TO_SEMITONE[16]={
  3042.     /*translate note code KC into more usable number of semitone*/
  3043.     0*64, 1*64, 2*64, 3*64,
  3044.     3*64, 4*64, 5*64, 6*64,
  3045.     6*64, 7*64, 8*64, 9*64,
  3046.     9*64,10*64,11*64,12*64
  3047. };
  3048.  
  3049. /* ---------- frequency counter  ---------- */
  3050. INLINE void OPM_CALC_FCOUNT(YM2151 *OPM , FM_CH *CH )
  3051. {
  3052.     if( CH->SLOT[SLOT1].Incr==-1)
  3053.     {
  3054.         int fc = CH->fc;
  3055.         int kc = CH->kcode;
  3056.  
  3057.         CALC_FCSLOT(&CH->SLOT[SLOT1] , OPM->KC_TABLE[fc + CH->SLOT[SLOT1].DT2] , kc );
  3058.         CALC_FCSLOT(&CH->SLOT[SLOT2] , OPM->KC_TABLE[fc + CH->SLOT[SLOT2].DT2] , kc );
  3059.         CALC_FCSLOT(&CH->SLOT[SLOT3] , OPM->KC_TABLE[fc + CH->SLOT[SLOT3].DT2] , kc );
  3060.         CALC_FCSLOT(&CH->SLOT[SLOT4] , OPM->KC_TABLE[fc + CH->SLOT[SLOT4].DT2] , kc );
  3061.     }
  3062. }
  3063.  
  3064. /* ---------- calcrate one of channel7 ---------- */
  3065. INLINE void OPM_CALC_CH7( FM_CH *CH )
  3066. {
  3067.     UINT32 eg_out1,eg_out2,eg_out3,eg_out4;  //envelope output
  3068.  
  3069.     /* Phase Generator */
  3070. #if FM_LFO_SUPPORT
  3071.     INT32 pms = lfo_pmd * CH->pms / LFO_RATE;
  3072.     if(pms)
  3073.     {
  3074.         pg_in1 = (CH->SLOT[SLOT1].Cnt += CH->SLOT[SLOT1].Incr + (INT32)(pms * CH->SLOT[SLOT1].Incr) / PMS_RATE);
  3075.         pg_in2 = (CH->SLOT[SLOT2].Cnt += CH->SLOT[SLOT2].Incr + (INT32)(pms * CH->SLOT[SLOT2].Incr) / PMS_RATE);
  3076.         pg_in3 = (CH->SLOT[SLOT3].Cnt += CH->SLOT[SLOT3].Incr + (INT32)(pms * CH->SLOT[SLOT3].Incr) / PMS_RATE);
  3077.         pg_in4 = (CH->SLOT[SLOT4].Cnt += CH->SLOT[SLOT4].Incr + (INT32)(pms * CH->SLOT[SLOT4].Incr) / PMS_RATE);
  3078.     }
  3079.     else
  3080. #endif
  3081.     {
  3082.         pg_in1 = (CH->SLOT[SLOT1].Cnt += CH->SLOT[SLOT1].Incr);
  3083.         pg_in2 = (CH->SLOT[SLOT2].Cnt += CH->SLOT[SLOT2].Incr);
  3084.         pg_in3 = (CH->SLOT[SLOT3].Cnt += CH->SLOT[SLOT3].Incr);
  3085.         pg_in4 = (CH->SLOT[SLOT4].Cnt += CH->SLOT[SLOT4].Incr);
  3086.     }
  3087.     /* Envelope Generator */
  3088.     FM_CALC_EG(eg_out1,CH->SLOT[SLOT1]);
  3089.     FM_CALC_EG(eg_out2,CH->SLOT[SLOT2]);
  3090.     FM_CALC_EG(eg_out3,CH->SLOT[SLOT3]);
  3091.     FM_CALC_EG(eg_out4,CH->SLOT[SLOT4]);
  3092.  
  3093.     /* connection */
  3094.     if( eg_out1 < EG_CUT_OFF )    /* SLOT 1 */
  3095.     {
  3096.         if( CH->FB ){
  3097.             /* with self feed back */
  3098.             pg_in1 += (CH->op1_out[0]+CH->op1_out[1])>>CH->FB;
  3099.             CH->op1_out[1] = CH->op1_out[0];
  3100.         }
  3101.         CH->op1_out[0] = OP_OUT(pg_in1,eg_out1);
  3102.         /* output slot1 */
  3103.         if( !CH->connect1 )
  3104.         {
  3105.             /* algorythm 5  */
  3106.             pg_in2 += CH->op1_out[0];
  3107.             pg_in3 += CH->op1_out[0];
  3108.             pg_in4 += CH->op1_out[0];
  3109.         }else{
  3110.             /* other algorythm */
  3111.             *CH->connect1 += CH->op1_out[0];
  3112.         }
  3113.     }
  3114.     if( eg_out2 < EG_CUT_OFF )    /* SLOT 2 */
  3115.         *CH->connect2 += OP_OUT(pg_in2,eg_out2);
  3116.     if( eg_out3 < EG_CUT_OFF )    /* SLOT 3 */
  3117.         *CH->connect3 += OP_OUT(pg_in3,eg_out3);
  3118.     /* SLOT 4 */
  3119.     if(NoiseIncr)
  3120.     {
  3121.         NoiseCnt += NoiseIncr;
  3122.         if( eg_out4 < EG_CUT_OFF )
  3123.             *CH->connect4 += OP_OUTN(NoiseCnt,eg_out4);
  3124.     }
  3125.     else
  3126.     {
  3127.         if( eg_out4 < EG_CUT_OFF )
  3128.             *CH->connect4 += OP_OUT(pg_in4,eg_out4);
  3129.     }
  3130. }
  3131.  
  3132. static int OPMInitTable(void)
  3133. {
  3134.     int i;
  3135.  
  3136.     /* NOISE wave table */
  3137.     for(i=0;i<SIN_ENT;i++)
  3138.     {
  3139.         int sign = rand()&1 ? TL_MAX : 0;
  3140.         int lev = rand()&0x1ff;
  3141.         //pom = lev ? 20*log10(0x200/lev) : 0;   /* decibel */
  3142.         //NOISE_TABLE[i] = &TL_TABLE[sign + (int)(pom / EG_STEP)]; /* TL_TABLE steps */
  3143.         NOISE_TABLE[i] = &TL_TABLE[sign + lev * EG_ENT/0x200]; /* TL_TABLE steps */
  3144.     }
  3145.  
  3146. #if FM_LFO_SUPPORT
  3147.     /* LFO wave tables , 4 pattern */
  3148.     for(i=0;i<LFO_ENT;i++)
  3149.     {
  3150.         OPM_LFO_waves[          i]= LFO_RATE * i / LFO_ENT /127;
  3151.         OPM_LFO_waves[LFO_ENT  +i]= ( i<LFO_ENT/2 ? 0 : LFO_RATE )/127;
  3152.         OPM_LFO_waves[LFO_ENT*2+i]= LFO_RATE* (i<LFO_ENT/2 ? i : LFO_ENT-i) /(LFO_ENT/2) /127;
  3153.         OPM_LFO_waves[LFO_ENT*3+i]= LFO_RATE * (rand()&0xff) /256 /127;
  3154.     }
  3155. #endif
  3156.     return FMInitTable();
  3157. }
  3158.  
  3159. /* ---------- priscaler set(and make time tables) ---------- */
  3160. static void OPMResetTable( int num )
  3161. {
  3162.     YM2151 *OPM = &(FMOPM[num]);
  3163.     int i;
  3164.     double pom;
  3165.     double rate;
  3166.  
  3167.     if (FMOPM[num].ST.rate)
  3168.         rate = (double)(1<<FREQ_BITS) / (3579545.0 / FMOPM[num].ST.clock * FMOPM[num].ST.rate);
  3169.     else rate = 1;
  3170.  
  3171.     for (i=0; i<8*12*64+950; i++)
  3172.     {
  3173.         /* This calculation type was used from the Jarek's YM2151 emulator */
  3174.         pom = 6.875 * pow (2, ((i+4*64)*1.5625/1200.0) ); /*13.75Hz is note A 12semitones below A-0, so D#0 is 4 semitones above then*/
  3175.         /*calculate phase increment for above precounted Hertz value*/
  3176.         OPM->KC_TABLE[i] = (UINT32)(pom * rate);
  3177.         /*LOG(LOG_WAR,("OPM KC %d = %x\n",i,OPM->KC_TABLE[i]));*/
  3178.     }
  3179.  
  3180.     /* make time tables */
  3181.     init_timetables( &OPM->ST , OPM_DTTABLE , OPM_ARRATE , OPM_DRRATE );
  3182.  
  3183. }
  3184.  
  3185. /* ---------- write a register on YM2151 chip number 'n' ---------- */
  3186. static void OPMWriteReg(int n, int r, int v)
  3187. {
  3188.     UINT8 c;
  3189.     FM_CH *CH;
  3190.     FM_SLOT *SLOT;
  3191.  
  3192.     YM2151 *OPM = &(FMOPM[n]);
  3193.  
  3194.     c   = OPM_CHAN(r);
  3195.     CH  = &OPM->CH[c];
  3196.     SLOT= &CH->SLOT[OPM_SLOT(r)];
  3197.  
  3198.     switch( r & 0xe0 ){
  3199.     case 0x00: /* 0x00-0x1f */
  3200.         switch( r ){
  3201. #if FM_LFO_SUPPORT
  3202.         case 0x01:    /* test */
  3203.             if( (OPM->testreg&(OPM->testreg^v))&0x02 ) /* fall eggge */
  3204.             {    /* reset LFO counter */
  3205.                 OPM->LFOCnt = 0;
  3206.                 cur_chip = NULL;
  3207.             }
  3208.             OPM->testreg = v;
  3209.             break;
  3210. #endif
  3211.         case 0x08:    /* key on / off */
  3212.             c = v&7;
  3213.             /* CSM mode */
  3214.             if( OPM->ST.mode & 0x80 ) break;
  3215.             CH = &OPM->CH[c];
  3216.             if(v&0x08) FM_KEYON(CH,SLOT1); else FM_KEYOFF(CH,SLOT1);
  3217.             if(v&0x10) FM_KEYON(CH,SLOT2); else FM_KEYOFF(CH,SLOT2);
  3218.             if(v&0x20) FM_KEYON(CH,SLOT3); else FM_KEYOFF(CH,SLOT3);
  3219.             if(v&0x40) FM_KEYON(CH,SLOT4); else FM_KEYOFF(CH,SLOT4);
  3220.             break;
  3221.         case 0x0f:    /* Noise freq (ch7.op4) */
  3222.             /* b7 = Noise enable */
  3223.             /* b0-4 noise freq  */
  3224.             OPM->NoiseIncr = !(v&0x80) ? 0 :
  3225.                 /* !!!!! unknown noise freqency rate !!!!! */
  3226.                 (UINT32)((1<<FREQ_BITS) / 65536 * (v&0x1f) * OPM->ST.freqbase);
  3227.             cur_chip = NULL;
  3228. #if 1
  3229.             if( v & 0x80 ){
  3230.                 LOG(LOG_WAR,("OPM Noise mode selelted\n"));
  3231.             }
  3232. #endif
  3233.             break;
  3234.         case 0x10:    /* timer A High 8*/
  3235.             OPM->ST.TA = (OPM->ST.TA & 0x03)|(((int)v)<<2);
  3236.             break;
  3237.         case 0x11:    /* timer A Low 2*/
  3238.             OPM->ST.TA = (OPM->ST.TA & 0x3fc)|(v&3);
  3239.             break;
  3240.         case 0x12:    /* timer B */
  3241.             OPM->ST.TB = v;
  3242.             break;
  3243.         case 0x14:    /* mode , timer controll */
  3244.             FMSetMode( &(OPM->ST),n,v );
  3245.             break;
  3246. #if FM_LFO_SUPPORT
  3247.         case 0x18:    /* lfreq   */
  3248.             /* f = fm * 2^(LFRQ/16) / (4295*10^6) */
  3249.             {
  3250.                 static double drate[16]={
  3251.                     1.0        ,1.044273782,1.090507733,1.138788635, //0-3
  3252.                     1.189207115,1.241857812,1.296839555,1.354255547, //4-7
  3253.                     1.414213562,1.476826146,1.542210825,1.610490332, //8-11
  3254.                     1.681792831,1.75625216 ,1.834008086,1.915206561};
  3255.                 double rate = pow(2.0,v/16)*drate[v&0x0f] / 4295000000.0;
  3256.                 OPM->LFOIncr = (UINT32)((double)LFO_ENT*(1<<LFO_SHIFT) * (OPM->ST.freqbase*64) * rate);
  3257.                 cur_chip = NULL;
  3258.             }
  3259.             break;
  3260.         case 0x19:    /* PMD/AMD */
  3261.             if( v & 0x80 ) OPM->pmd = v & 0x7f;
  3262.             else           OPM->amd = v & 0x7f;
  3263.             break;
  3264. #endif
  3265.         case 0x1b:    /* CT , W  */
  3266.             /* b7 = CT1 */
  3267.             /* b6 = CT0 */
  3268.             /* b0-2 = wave form(LFO) 0=nokogiri,1=houkei,2=sankaku,3=noise */
  3269.             //if(OPM->ct != v)
  3270.             {
  3271.                 OPM->ct = v>>6;
  3272.                 if( OPM->PortWrite != 0)
  3273.                     OPM->PortWrite(0, OPM->ct ); /* bit0 = CT0,bit1 = CT1 */
  3274.             }
  3275. #if FM_LFO_SUPPORT
  3276.             if( OPM->wavetype != &OPM_LFO_waves[(v&3)*LFO_ENT])
  3277.             {
  3278.                 OPM->wavetype = &OPM_LFO_waves[(v&3)*LFO_ENT];
  3279.                 cur_chip = NULL;
  3280.             }
  3281. #endif
  3282.             break;
  3283.         }
  3284.         break;
  3285.     case 0x20:    /* 20-3f */
  3286.         switch( OPM_SLOT(r) ){
  3287.         case 0: /* 0x20-0x27 : RL,FB,CON */
  3288.             {
  3289.                 int feedback = (v>>3)&7;
  3290.                 CH->ALGO = v&7;
  3291.                 CH->FB  = feedback ? 8+1 - feedback : 0;
  3292.                 /* RL order -> LR order */
  3293.                 CH->PAN = ((v>>7)&1) | ((v>>5)&2);
  3294.                 setup_connection( CH );
  3295.             }
  3296.             break;
  3297.         case 1: /* 0x28-0x2f : Keycode */
  3298.             {
  3299.                 int blk = (v>>4)&7;
  3300.                 /* make keyscale code */
  3301.                 CH->kcode = (v>>2)&0x1f;
  3302.                 /* make basic increment counter 22bit = 1 cycle */
  3303.                 CH->fc = (blk * (12*64)) + KC_TO_SEMITONE[v&0x0f] + CH->fn_h;
  3304.                 CH->SLOT[SLOT1].Incr=-1;
  3305.             }
  3306.             break;
  3307.         case 2: /* 0x30-0x37 : Keyfunction */
  3308.             CH->fc -= CH->fn_h;
  3309.             CH->fn_h = v>>2;
  3310.             CH->fc += CH->fn_h;
  3311.             CH->SLOT[SLOT1].Incr=-1;
  3312.             break;
  3313. #if FM_LFO_SUPPORT
  3314.         case 3: /* 0x38-0x3f : PMS / AMS */
  3315.             /* b0-1 AMS */
  3316.             /* AMS * 23.90625db @ AMD=127 */
  3317.             //CH->ams = (v & 0x03) * (23.90625/EG_STEP);
  3318.             CH->ams = (UINT32)( (23.90625/EG_STEP) / (1<<(3-(v&3))) );
  3319.             CH->SLOT[SLOT1].ams = CH->ams * CH->SLOT[SLOT1].amon;
  3320.             CH->SLOT[SLOT2].ams = CH->ams * CH->SLOT[SLOT2].amon;
  3321.             CH->SLOT[SLOT3].ams = CH->ams * CH->SLOT[SLOT3].amon;
  3322.             CH->SLOT[SLOT4].ams = CH->ams * CH->SLOT[SLOT4].amon;
  3323.             /* b4-6 PMS */
  3324.             /* 0,5,10,20,50,100,400,700 (cent) @ PMD=127 */
  3325.             {
  3326.                 /* 1 octabe = 1200cent = +100%/-50% */
  3327.                 /* 100cent  = 1seminote = 6% ?? */
  3328.                 static const int pmd_table[8] = {0,5,10,20,50,100,400,700};
  3329.                 CH->pms = (INT32)( (1.5/1200.0)*pmd_table[(v>>4) & 0x07] * PMS_RATE );
  3330.             }
  3331.             break;
  3332. #endif
  3333.         }
  3334.         break;
  3335.     case 0x40:    /* DT1,MUL */
  3336.         set_det_mul(&OPM->ST,CH,SLOT,v);
  3337.         break;
  3338.     case 0x60:    /* TL */
  3339.         set_tl(CH,SLOT,v,(OPM->ST.mode & 0x80) );
  3340.         break;
  3341.     case 0x80:    /* KS, AR */
  3342.         set_ar_ksr(CH,SLOT,v,OPM->ST.AR_TABLE);
  3343.         break;
  3344.     case 0xa0:    /* AMS EN,D1R */
  3345.         set_dr(SLOT,v,OPM->ST.DR_TABLE);
  3346. #if FM_LFO_SUPPORT
  3347.         /* bit7 = AMS ENABLE */
  3348.         SLOT->amon = v>>7;
  3349.         SLOT->ams = CH->ams * SLOT->amon;
  3350. #endif
  3351.         break;
  3352.     case 0xc0:    /* DT2 ,D2R */
  3353.         SLOT->DT2  = DT2_TABLE[v>>6];
  3354.         CH->SLOT[SLOT1].Incr=-1;
  3355.         set_sr(SLOT,v,OPM->ST.DR_TABLE);
  3356.         break;
  3357.     case 0xe0:    /* D1L, RR */
  3358.         set_sl_rr(SLOT,v,OPM->ST.DR_TABLE);
  3359.         break;
  3360.     }
  3361. }
  3362.  
  3363. /* ---------- read status port ---------- */
  3364. static UINT8 OPMReadStatus(int n)
  3365. {
  3366.     return FMOPM[n].ST.status;
  3367. }
  3368.  
  3369. int YM2151Write(int n,int a,UINT8 v)
  3370. {
  3371.     YM2151 *F2151 = &(FMOPM[n]);
  3372.  
  3373.     if( !(a&1) )
  3374.     {    /* address port */
  3375.         F2151->ST.address = v & 0xff;
  3376.     }
  3377.     else
  3378.     {    /* data port */
  3379.         int addr = F2151->ST.address;
  3380.         YM2151UpdateReq(n);
  3381.         /* write register */
  3382.          OPMWriteReg(n,addr,v);
  3383.     }
  3384.     return F2151->ST.irq;
  3385. }
  3386.  
  3387. /* ---------- reset one of chip ---------- */
  3388. void OPMResetChip(int num)
  3389. {
  3390.     int i;
  3391.     YM2151 *OPM = &(FMOPM[num]);
  3392.  
  3393.     OPMResetTable( num );
  3394.     reset_channel( &OPM->ST , &OPM->CH[0] , 8 );
  3395.     /* status clear */
  3396.     FM_IRQMASK_SET(&OPM->ST,0x03);
  3397.     OPMWriteReg(num,0x1b,0x00);
  3398.     /* reset OPerator paramater */
  3399.     for(i = 0xff ; i >= 0x20 ; i-- ) OPMWriteReg(num,i,0);
  3400. }
  3401.  
  3402. /* ----------  Initialize YM2151 emulator(s) ----------    */
  3403. /* 'num' is the number of virtual YM2151's to allocate     */
  3404. /* 'rate' is sampling rate and 'bufsiz' is the size of the */
  3405. /* buffer that should be updated at each interval          */
  3406. int OPMInit(int num, int clock, int rate,
  3407.                FM_TIMERHANDLER TimerHandler,FM_IRQHANDLER IRQHandler)
  3408. {
  3409.     int i;
  3410.  
  3411.     if (FMOPM) return (-1);    /* duplicate init. */
  3412.     cur_chip = NULL;    /* hiro-shi!! */
  3413.  
  3414.     YM2151NumChips = num;
  3415.  
  3416.     /* allocate ym2151 state space */
  3417.     if( (FMOPM = (YM2151 *)malloc(sizeof(YM2151) * YM2151NumChips))==NULL)
  3418.         return (-1);
  3419.  
  3420.     /* clear */
  3421.     memset(FMOPM,0,sizeof(YM2151) * YM2151NumChips);
  3422.  
  3423.     /* allocate total lebel table (128kb space) */
  3424.     if( !OPMInitTable() )
  3425.     {
  3426.         free( FMOPM );
  3427.         return (-1);
  3428.     }
  3429.     for ( i = 0 ; i < YM2151NumChips; i++ ) {
  3430.         FMOPM[i].ST.index = i;
  3431.         FMOPM[i].ST.clock = clock;
  3432.         FMOPM[i].ST.rate = rate;
  3433.         /* FMOPM[i].ST.irq  = 0; */
  3434.         /* FMOPM[i].ST.status = 0; */
  3435.         FMOPM[i].ST.timermodel = FM_TIMER_INTERVAL;
  3436.         FMOPM[i].ST.freqbase  = rate ? ((double)clock / rate) / 64 : 0;
  3437.         FMOPM[i].ST.TimerBase = 1.0/((double)clock / 64.0);
  3438.         /* Extend handler */
  3439.         FMOPM[i].ST.Timer_Handler = TimerHandler;
  3440.         FMOPM[i].ST.IRQ_Handler   = IRQHandler;
  3441.         /* Reset callback handler of CT0/1 */
  3442.         FMOPM[i].PortWrite = 0;
  3443.         OPMResetChip(i);
  3444.     }
  3445.     return(0);
  3446. }
  3447.  
  3448. /* ---------- shut down emurator ----------- */
  3449. void OPMShutdown()
  3450. {
  3451.     if (!FMOPM) return;
  3452.  
  3453.     FMCloseTable();
  3454.     free(FMOPM);
  3455.     FMOPM = NULL;
  3456. }
  3457.  
  3458. UINT8 YM2151Read(int n,int a)
  3459. {
  3460.     if( !(a&1) ) return 0;
  3461.     else         return FMOPM[n].ST.status;
  3462. }
  3463.  
  3464. /* ---------- make digital sound data ---------- */
  3465. void OPMUpdateOne(int num, INT16 **buffer, int length)
  3466. {
  3467.     YM2151 *OPM = &(FMOPM[num]);
  3468.     int i;
  3469.     int amd,pmd;
  3470.     FM_CH *ch;
  3471.     FMSAMPLE  *bufL,*bufR;
  3472.  
  3473.     /* set bufer */
  3474.     bufL = buffer[0];
  3475.     bufR = buffer[1];
  3476.  
  3477.     if( (void *)OPM != cur_chip ){
  3478.         cur_chip = (void *)OPM;
  3479.  
  3480.         State = &OPM->ST;
  3481.         /* channel pointer */
  3482.         cch[0] = &OPM->CH[0];
  3483.         cch[1] = &OPM->CH[1];
  3484.         cch[2] = &OPM->CH[2];
  3485.         cch[3] = &OPM->CH[3];
  3486.         cch[4] = &OPM->CH[4];
  3487.         cch[5] = &OPM->CH[5];
  3488.         cch[6] = &OPM->CH[6];
  3489.         cch[7] = &OPM->CH[7];
  3490.         /* ch7.op4 noise mode / step */
  3491.         NoiseIncr = OPM->NoiseIncr;
  3492.         NoiseCnt  = OPM->NoiseCnt;
  3493. #if FM_LFO_SUPPORT
  3494.         /* LFO */
  3495.         LFOCnt  = OPM->LFOCnt;
  3496.         //LFOIncr = OPM->LFOIncr;
  3497.         if( !LFOIncr ) lfo_amd = lfo_pmd = 0;
  3498.         OPM_LFO_wave = OPM->wavetype;
  3499. #endif
  3500.     }
  3501.     amd = OPM->amd;
  3502.     pmd = OPM->pmd;
  3503.     if(amd==0 && pmd==0)
  3504.         LFOIncr = 0;
  3505.     else
  3506.         LFOIncr = OPM->LFOIncr;
  3507.  
  3508.     OPM_CALC_FCOUNT( OPM , cch[0] );
  3509.     OPM_CALC_FCOUNT( OPM , cch[1] );
  3510.     OPM_CALC_FCOUNT( OPM , cch[2] );
  3511.     OPM_CALC_FCOUNT( OPM , cch[3] );
  3512.     OPM_CALC_FCOUNT( OPM , cch[4] );
  3513.     OPM_CALC_FCOUNT( OPM , cch[5] );
  3514.     OPM_CALC_FCOUNT( OPM , cch[6] );
  3515.     OPM_CALC_FCOUNT( OPM , cch[7] );
  3516.  
  3517.     for( i=0; i < length ; i++ )
  3518.     {
  3519. #if FM_LFO_SUPPORT
  3520.         /* LFO */
  3521.         if( LFOIncr )
  3522.         {
  3523.             INT32 depth = OPM_LFO_wave[(LFOCnt+=LFOIncr)>>LFO_SHIFT];
  3524.             lfo_amd = depth * amd;
  3525.             lfo_pmd = (depth-(LFO_RATE/127/2)) * pmd;
  3526.         }
  3527. #endif
  3528.         /* clear output acc. */
  3529.         out_ch[OUTD_LEFT] = out_ch[OUTD_RIGHT]= out_ch[OUTD_CENTER] = 0;
  3530.         /* calcrate channel output */
  3531.         for(ch = cch[0] ; ch <= cch[6] ; ch++)
  3532.             FM_CALC_CH( ch );
  3533.         OPM_CALC_CH7( cch[7] );
  3534.         /* buffering */
  3535.         FM_BUFFERING_STEREO;
  3536.         /* timer A controll */
  3537.         INTERNAL_TIMER_A( State , cch[7] )
  3538.     }
  3539.     INTERNAL_TIMER_B(State,length)
  3540.     OPM->NoiseCnt = NoiseCnt;
  3541. #if FM_LFO_SUPPORT
  3542.     OPM->LFOCnt = LFOCnt;
  3543. #endif
  3544. }
  3545.  
  3546. void OPMSetPortHander(int n,mem_write_handler PortWrite)
  3547. {
  3548.     FMOPM[n].PortWrite = PortWrite;
  3549. }
  3550.  
  3551. int YM2151TimerOver(int n,int c)
  3552. {
  3553.     YM2151 *F2151 = &(FMOPM[n]);
  3554.  
  3555.     if( c )
  3556.     {    /* Timer B */
  3557.         TimerBOver( &(F2151->ST) );
  3558.     }
  3559.     else
  3560.     {    /* Timer A */
  3561.         YM2151UpdateReq(n);
  3562.         /* timer update */
  3563.         TimerAOver( &(F2151->ST) );
  3564.         /* CSM mode key,TL controll */
  3565.         if( F2151->ST.mode & 0x80 )
  3566.         {    /* CSM mode total level latch and auto key on */
  3567.             CSMKeyControll( &(F2151->CH[0]) );
  3568.             CSMKeyControll( &(F2151->CH[1]) );
  3569.             CSMKeyControll( &(F2151->CH[2]) );
  3570.             CSMKeyControll( &(F2151->CH[3]) );
  3571.             CSMKeyControll( &(F2151->CH[4]) );
  3572.             CSMKeyControll( &(F2151->CH[5]) );
  3573.             CSMKeyControll( &(F2151->CH[6]) );
  3574.             CSMKeyControll( &(F2151->CH[7]) );
  3575.         }
  3576.     }
  3577.     return F2151->ST.irq;
  3578. }
  3579.  
  3580. #endif /* BUILD_YM2151 */
  3581.